[#4006] Add <T> Field<T[]> array(Field<T>...)

jOOQ/src/main/java/org/jooq/impl/Array.java

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2009-2015, Data Geekery GmbH (http://www.datageekery.com)
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Other licenses:
+ * -----------------------------------------------------------------------------
+ * Commercial licenses for this work are available. These replace the above
+ * ASL 2.0 and offer limited warranties, support, maintenance, and commercial
+ * database integrations.
+ *
+ * For more information, please visit: http://www.jooq.org/licenses
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+package org.jooq.impl;
+
+import static org.jooq.SQLDialect.POSTGRES;
+
+import java.util.Collection;
+
+import org.jooq.Context;
+import org.jooq.DataType;
+import org.jooq.Field;
+import org.jooq.Record;
+
+/**
+ * @author Lukas Eder
+ */
+class Array<T> extends AbstractField<T[]> {
+
+    /**
+     * Generated UID
+     */
+    private static final long    serialVersionUID = -6629785423729163857L;
+
+    private final Fields<Record> fields;
+
+    Array(Collection<? extends Field<T>> fields) {
+        super("array", type(fields));
+
+        this.fields = new Fields<Record>(fields);
+    }
+
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    private static <T> DataType<T[]> type(Collection<? extends Field<T>> fields) {
+        if (fields == null || fields.isEmpty())
+            return (DataType) SQLDataType.OTHER.getArrayDataType();
+        else
+            return fields.iterator().next().getDataType().getArrayDataType();
+    }
+
+    @Override
+    public final void accept(Context<?> ctx) {
+        switch (ctx.family()) {
+            case H2:
+                ctx.sql('(').visit(fields).sql(')');
+                break;
+
+            case HSQLDB:
+            case POSTGRES:
+            default:
+                ctx.keyword("array")
+                   .sql('[')
+                   .visit(fields)
+                   .sql(']');
+
+                if (fields.fields.length == 0 && ctx.family() == POSTGRES)
+                    ctx.sql("::").keyword("int[]");
+
+                break;
+        }
+    }
+}

jOOQ/src/main/java/org/jooq/impl/DSL.java

@@ -11272,6 +11272,90 @@ public class DSL {
         return new Function<T[]>(Term.ARRAY_AGG, field.getDataType().getArrayDataType(), nullSafe(field));
     }
 
+    /**
+     * Create an array literal.
+     * <p>
+     * This translates to the following databases and syntaxes:
+     * <table>
+     * <tr>
+     * <th><code>SQLDialect</code></th>
+     * <th>Java</th>
+     * <th>SQL</th>
+     * </tr>
+     * <tr>
+     * <td>{@link SQLDialect#H2}</td>
+     * <td>array(1, 2)</td>
+     * <td>(1, 2)</td>
+     * </tr>
+     * <tr>
+     * <td>{@link SQLDialect#HSQLDB}, {@link SQLDialect#POSTGRES}</td>
+     * <td>array(1, 2)</td>
+     * <td>array[1, 2]</td>
+     * </tr>
+     * </table>
+     */
+    @Support({ H2, HSQLDB, POSTGRES })
+    public static <T> Field<T[]> array(T... values) {
+        return array(Utils.fields(values));
+    }
+
+    /**
+     * Create an array literal.
+     * <p>
+     * This translates to the following databases and syntaxes:
+     * <table>
+     * <tr>
+     * <th><code>SQLDialect</code></th>
+     * <th>Java</th>
+     * <th>SQL</th>
+     * </tr>
+     * <tr>
+     * <td>{@link SQLDialect#H2}</td>
+     * <td>array(1, 2)</td>
+     * <td>(1, 2)</td>
+     * </tr>
+     * <tr>
+     * <td>{@link SQLDialect#HSQLDB}, {@link SQLDialect#POSTGRES}</td>
+     * <td>array(1, 2)</td>
+     * <td>array[1, 2]</td>
+     * </tr>
+     * </table>
+     */
+    /* [java-8] */
+    @SafeVarargs
+    /* [/java-8] */
+    @Support({ H2, HSQLDB, POSTGRES })
+    public static <T> Field<T[]> array(Field<T>... fields) {
+        return array(Arrays.asList(fields));
+    }
+
+    /**
+     * Create an array literal.
+     * <p>
+     * This translates to the following databases and syntaxes:
+     * <table>
+     * <tr>
+     * <th><code>SQLDialect</code></th>
+     * <th>Java</th>
+     * <th>SQL</th>
+     * </tr>
+     * <tr>
+     * <td>{@link SQLDialect#H2}</td>
+     * <td>array(1, 2)</td>
+     * <td>(1, 2)</td>
+     * </tr>
+     * <tr>
+     * <td>{@link SQLDialect#HSQLDB}, {@link SQLDialect#POSTGRES}</td>
+     * <td>array(1, 2)</td>
+     * <td>array[1, 2]</td>
+     * </tr>
+     * </table>
+     */
+    @Support({ H2, HSQLDB, POSTGRES })
+    public static <T> Field<T[]> array(Collection<? extends Field<T>> fields) {
+        return new Array<T>(fields);
+    }
+
     /**
      * Get the max value over a field: max(field).
      */

jOOQ/src/main/java/org/jooq/impl/Utils.java

@@ -866,14 +866,12 @@ final class Utils {
      * @return The argument objects themselves, if they are {@link Field}s, or a bind
      *         values created from the argument objects.
      */
-    static final List<Field<?>> fields(Object[] values) {
-        List<Field<?>> result = new ArrayList<Field<?>>();
+    static final <T> List<Field<T>> fields(T[] values) {
+        List<Field<T>> result = new ArrayList<Field<T>>();
 
-        if (values != null) {
-            for (Object value : values) {
+        if (values != null)
+            for (T value : values)
                 result.add(field(value));
-            }
-        }
 
         return result;
     }