From 6ec1958876cf633b47feeab212ee82ef4191b9be Mon Sep 17 00:00:00 2001 From: lukaseder Date: Wed, 23 May 2018 12:57:30 +0200 Subject: [PATCH] [#7497] Adaptations after the merge --- .../codegen/AbstractGeneratorStrategy.java | 12 ++-- .../src/main/resources/org/jooq/web/ABOUT.txt | 1 + .../java/org/jooq/meta/AbstractDatabase.java | 4 +- .../java/org/jooq/impl/AbstractDMLQuery.java | 2 +- .../java/org/jooq/impl/AbstractField.java | 21 +++--- .../java/org/jooq/impl/AbstractRoutine.java | 21 +++--- .../main/java/org/jooq/impl/BatchSingle.java | 14 ++-- jOOQ/src/main/java/org/jooq/impl/DDL.java | 1 + .../java/org/jooq/impl/DefaultDSLContext.java | 18 ++--- .../java/org/jooq/impl/InsertQueryImpl.java | 9 +-- .../main/java/org/jooq/impl/JSONReader.java | 1 + .../main/java/org/jooq/impl/MergeImpl.java | 16 ++--- .../main/java/org/jooq/impl/RowCondition.java | 2 +- .../main/java/org/jooq/impl/RowIsNull.java | 5 +- .../org/jooq/impl/RowSubqueryCondition.java | 15 ++-- jOOQ/src/main/java/org/jooq/impl/Tools.java | 69 +++++++++++-------- 16 files changed, 104 insertions(+), 107 deletions(-) diff --git a/jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractGeneratorStrategy.java b/jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractGeneratorStrategy.java index 980eadfe51..8d41720b87 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractGeneratorStrategy.java +++ b/jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractGeneratorStrategy.java @@ -234,9 +234,8 @@ public abstract class AbstractGeneratorStrategy implements GeneratorStrategy { List nonNull = nonNull(definitions); List result = new ArrayList(nonNull.size()); - for (Definition definition : nonNull) { + for (Definition definition : nonNull) result.add(getJavaIdentifier(definition)); - } return result; } @@ -251,9 +250,8 @@ public abstract class AbstractGeneratorStrategy implements GeneratorStrategy { List nonNull = nonNull(definitions); List result = new ArrayList(nonNull.size()); - for (Definition definition : nonNull) { + for (Definition definition : nonNull) result.add(getFullJavaIdentifier(definition)); - } return result; } @@ -266,11 +264,9 @@ public abstract class AbstractGeneratorStrategy implements GeneratorStrategy { private static final List nonNull(Collection collection) { List result = new ArrayList(); - for (T t : collection) { - if (t != null) { + for (T t : collection) + if (t != null) result.add(t); - } - } return result; } diff --git a/jOOQ-manual/src/main/resources/org/jooq/web/ABOUT.txt b/jOOQ-manual/src/main/resources/org/jooq/web/ABOUT.txt index 7d0abff196..2e1da7cea7 100644 --- a/jOOQ-manual/src/main/resources/org/jooq/web/ABOUT.txt +++ b/jOOQ-manual/src/main/resources/org/jooq/web/ABOUT.txt @@ -48,6 +48,7 @@ Authors and contributors of jOOQ or parts of jOOQ in alphabetical order: - Sven Jacobs - Szymon Jachim - Terence Zhang +- Timothy Wilson - Timur Shaidullin - Thomas Darimont - Tsukasa Kitachi diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/AbstractDatabase.java b/jOOQ-meta/src/main/java/org/jooq/meta/AbstractDatabase.java index f399da69d6..fc74fe3af4 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/AbstractDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/AbstractDatabase.java @@ -1344,10 +1344,10 @@ public abstract class AbstractDatabase implements Database { String literals = enumType.getLiterals(); try { - @SuppressWarnings("resource") CSVReader reader = new CSVReader(new StringReader(literals)); e.addLiterals(reader.readNext()); - } catch (IOException ignore) {} + } + catch (IOException ignore) {} result.add(e); } diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractDMLQuery.java b/jOOQ/src/main/java/org/jooq/impl/AbstractDMLQuery.java index 6d4e735ca8..9cffd4ebd9 100644 --- a/jOOQ/src/main/java/org/jooq/impl/AbstractDMLQuery.java +++ b/jOOQ/src/main/java/org/jooq/impl/AbstractDMLQuery.java @@ -573,7 +573,7 @@ abstract class AbstractDMLQuery extends AbstractQuery { case HSQLDB: default: { - List names = new ArrayList(returningResolvedAsterisks.size()); + List names = new ArrayList(); RenderNameStyle style = configuration().settings().getRenderNameStyle(); for (Field field : returningResolvedAsterisks) { diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java index 58bb8913ba..960bebb97c 100644 --- a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java +++ b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java @@ -66,11 +66,10 @@ import static org.jooq.tools.Convert.TRUE_VALUES; import java.math.BigDecimal; import java.sql.Timestamp; -import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; +import java.util.Iterator; import java.util.LinkedHashMap; -import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.function.Function; @@ -947,12 +946,13 @@ abstract class AbstractField extends AbstractNamed implements Field { @Override public final Condition in(Collection values) { - List> fields = new ArrayList>(values.size()); + Field[] fields = new Field[values.size()]; - for (Object value : values) - fields.add(Tools.field(value, this)); + Iterator it = values.iterator(); + for (int i = 0; it.hasNext(); i++) + fields[i] = Tools.field(it.next(), this); - return in(fields.toArray(EMPTY_FIELD)); + return in(fields); } @Override @@ -987,12 +987,13 @@ abstract class AbstractField extends AbstractNamed implements Field { @Override public final Condition notIn(Collection values) { - List> fields = new ArrayList>(values.size()); + Field[] fields = new Field[values.size()]; - for (Object value : values) - fields.add(Tools.field(value, this)); + Iterator it = values.iterator(); + for (int i = 0; it.hasNext(); i++) + fields[i] = Tools.field(it.next(), this); - return notIn(fields.toArray(EMPTY_FIELD)); + return notIn(fields); } @Override diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java b/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java index 57295b6ab0..651a3cd7de 100644 --- a/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java +++ b/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java @@ -75,7 +75,6 @@ import static org.jooq.impl.Keywords.K_TRUE; import static org.jooq.impl.Keywords.K_TYPE; import static org.jooq.impl.Keywords.K_WHEN; import static org.jooq.impl.Keywords.K_XMLTABLE; -import static org.jooq.impl.Tools.EMPTY_FIELD; import static org.jooq.impl.Tools.executeStatementAndGetFirstResultSet; import static org.jooq.impl.Tools.settings; @@ -86,6 +85,7 @@ import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; +import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -1606,9 +1606,10 @@ public abstract class AbstractRoutine extends AbstractNamed implements Routin RenderContext local = create(ctx).renderContext(); toSQLQualifiedName(local); - List> fields = new ArrayList>(getInParameters().size()); - for (Parameter parameter : getInParameters()) { - + Field[] fields = new Field[getInParameters().size()]; + Iterator> it = getInParameters().iterator(); + for (int i = 0; it.hasNext(); i++) { + Parameter parameter = it.next(); // [#1183] [#3533] Skip defaulted parameters if (inValuesDefaulted.contains(parameter)) continue; @@ -1619,19 +1620,19 @@ public abstract class AbstractRoutine extends AbstractNamed implements Routin // [#4920] In case there are any unnamed parameters, we mustn't if (hasUnnamedParameters()) if (pgArgNeedsCasting(parameter)) - fields.add(new Cast(getInValues().get(parameter), parameter.getDataType())); + fields[i] = new Cast(getInValues().get(parameter), parameter.getDataType()); else - fields.add(getInValues().get(parameter)); + fields[i] = getInValues().get(parameter); else if (pgArgNeedsCasting(parameter)) - fields.add(DSL.field("{0} := {1}", name(parameter.getName()), new Cast(getInValues().get(parameter), parameter.getDataType()))); + fields[i] = DSL.field("{0} := {1}", name(parameter.getName()), new Cast(getInValues().get(parameter), parameter.getDataType())); else - fields.add(DSL.field("{0} := {1}", name(parameter.getName()), getInValues().get(parameter))); + fields[i] = DSL.field("{0} := {1}", name(parameter.getName()), getInValues().get(parameter)); else - fields.add(getInValues().get(parameter)); + fields[i] = getInValues().get(parameter); } - Field result = function(local.render(), getDataType(), fields.toArray(EMPTY_FIELD)); + Field result = function(local.render(), getDataType(), fields); // [#3592] Decrease SQL -> PL/SQL context switches with Oracle Scalar Subquery Caching diff --git a/jOOQ/src/main/java/org/jooq/impl/BatchSingle.java b/jOOQ/src/main/java/org/jooq/impl/BatchSingle.java index ed4455b2aa..a2681838ff 100644 --- a/jOOQ/src/main/java/org/jooq/impl/BatchSingle.java +++ b/jOOQ/src/main/java/org/jooq/impl/BatchSingle.java @@ -39,7 +39,6 @@ package org.jooq.impl; import static org.jooq.conf.ParamType.INLINED; import static org.jooq.conf.SettingsTools.executeStaticStatements; -import static org.jooq.impl.Tools.EMPTY_FIELD; import static org.jooq.impl.Tools.dataTypes; import static org.jooq.impl.Tools.fields; import static org.jooq.impl.Tools.visitAll; @@ -47,6 +46,7 @@ import static org.jooq.impl.Tools.visitAll; import java.sql.Connection; import java.sql.SQLException; import java.util.ArrayList; +import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -200,11 +200,12 @@ final class BatchSingle implements BatchBindStep { // [#4062] Make sure we collect also repeated named parameters ParamCollector collector = new ParamCollector(configuration, false); collector.visit(query); - List> params = new ArrayList>(collector.resultList.size()); - for (Entry> entry : collector.resultList) - params.add(entry.getValue()); + Param[] params = new Param[collector.resultList.size()]; + Iterator>> it = collector.resultList.iterator(); + for (int i = 0; it.hasNext(); i++) + params[i] = it.next().getValue(); - DataType[] paramTypes = dataTypes(params.toArray(EMPTY_FIELD)); + DataType[] paramTypes = dataTypes(params); try { listener.renderStart(ctx); @@ -266,9 +267,8 @@ final class BatchSingle implements BatchBindStep { List queries = new ArrayList(allBindValues.size()); for (Object[] bindValues : allBindValues) { - for (int i = 0; i < bindValues.length; i++) { + for (int i = 0; i < bindValues.length; i++) query.bind(i + 1, bindValues[i]); - } queries.add(create.query(query.getSQL(INLINED))); } diff --git a/jOOQ/src/main/java/org/jooq/impl/DDL.java b/jOOQ/src/main/java/org/jooq/impl/DDL.java index b836efb1c2..ec414584c9 100644 --- a/jOOQ/src/main/java/org/jooq/impl/DDL.java +++ b/jOOQ/src/main/java/org/jooq/impl/DDL.java @@ -88,6 +88,7 @@ final class DDL { private final List alterTableAddConstraints(Table table) { List constraints = constraints(table); List result = new ArrayList(constraints.size()); + for (Constraint constraint : constraints) result.add(ctx.alterTable(table).add(constraint)); diff --git a/jOOQ/src/main/java/org/jooq/impl/DefaultDSLContext.java b/jOOQ/src/main/java/org/jooq/impl/DefaultDSLContext.java index 1122e66592..2b85031cc4 100644 --- a/jOOQ/src/main/java/org/jooq/impl/DefaultDSLContext.java +++ b/jOOQ/src/main/java/org/jooq/impl/DefaultDSLContext.java @@ -1460,22 +1460,14 @@ public class DefaultDSLContext extends AbstractScope implements DSLContext, Seri } else { List> fields = new ArrayList>(strings.get(0).length); - int firstRow; + int firstRow = header ? 1 : 0; - if (header) { - firstRow = 1; - - for (String name : strings.get(0)) { + if (header) + for (String name : strings.get(0)) fields.add(field(name(name), String.class)); - } - } - else { - firstRow = 0; - - for (int i = 0; i < strings.get(0).length; i++) { + else + for (int i = 0; i < strings.get(0).length; i++) fields.add(field(name("COL" + (i + 1)), String.class)); - } - } Result result = new ResultImpl(configuration(), fields); diff --git a/jOOQ/src/main/java/org/jooq/impl/InsertQueryImpl.java b/jOOQ/src/main/java/org/jooq/impl/InsertQueryImpl.java index fbaeef9753..5a7aa97eec 100644 --- a/jOOQ/src/main/java/org/jooq/impl/InsertQueryImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/InsertQueryImpl.java @@ -639,15 +639,16 @@ final class InsertQueryImpl extends AbstractStoreQuery impl else if (onConstraintUniqueKey != null) return Collections.singletonList(onConstraintUniqueKey.getFields()); - // [#6462] MySQL ON DUPLICATGE KEY UPDATE clause + // [#6462] MySQL ON DUPLICATE KEY UPDATE clause // Flag for backwards compatibility considers only PRIMARY KEY else if (TRUE.equals(Tools.settings(configuration).isEmulateOnDuplicateKeyUpdateOnPrimaryKeyOnly())) return Collections.singletonList(table.getPrimaryKey().getFields()); - // [#6462] MySQL ON DUPLICATGE KEY UPDATE clause + // [#6462] MySQL ON DUPLICATE KEY UPDATE clause // All conflicting keys are considered - List>> result = new ArrayList>>(table.getKeys().size()); - for (UniqueKey key : table.getKeys()) + List> keys = table.getKeys(); + List>> result = new ArrayList>>(keys.size()); + for (UniqueKey key : keys) result.add(key.getFields()); return result; diff --git a/jOOQ/src/main/java/org/jooq/impl/JSONReader.java b/jOOQ/src/main/java/org/jooq/impl/JSONReader.java index d84814426c..f31d22c342 100644 --- a/jOOQ/src/main/java/org/jooq/impl/JSONReader.java +++ b/jOOQ/src/main/java/org/jooq/impl/JSONReader.java @@ -103,6 +103,7 @@ final class JSONReader implements Closeable { private final void readRecords(LinkedHashMap> jsonRoot) { LinkedList rootRecords = jsonRoot.get("records"); records = new ArrayList(rootRecords.size()); + for (Object record : rootRecords) { String[] v = new String[fieldNames.length]; int i = 0; diff --git a/jOOQ/src/main/java/org/jooq/impl/MergeImpl.java b/jOOQ/src/main/java/org/jooq/impl/MergeImpl.java index 1163cac59b..2839e5a9b0 100644 --- a/jOOQ/src/main/java/org/jooq/impl/MergeImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/MergeImpl.java @@ -55,7 +55,6 @@ import static org.jooq.impl.DSL.exists; import static org.jooq.impl.DSL.insertInto; import static org.jooq.impl.DSL.notExists; import static org.jooq.impl.DSL.nullSafe; -import static org.jooq.impl.DSL.row; import static org.jooq.impl.Keywords.K_AND; import static org.jooq.impl.Keywords.K_AS; import static org.jooq.impl.Keywords.K_DELETE_WHERE; @@ -286,25 +285,22 @@ implements // ------------------------------------------------------------------------- QueryPartList> getUpsertFields() { - if (upsertFields == null) { + if (upsertFields == null) upsertFields = new QueryPartList>(table.fields()); - } return upsertFields; } QueryPartList> getUpsertKeys() { - if (upsertKeys == null) { + if (upsertKeys == null) upsertKeys = new QueryPartList>(); - } return upsertKeys; } QueryPartList> getUpsertValues() { - if (upsertValues == null) { + if (upsertValues == null) upsertValues = new QueryPartList>(); - } return upsertValues; } @@ -1213,9 +1209,8 @@ implements Row row = upsertSelect.fieldsRow(); List> v = new ArrayList>(row.size()); - for (int i = 0; i < row.size(); i++) { + for (int i = 0; i < row.size(); i++) v.add(row.field(i).as("s" + (i + 1))); - } // [#579] TODO: Currently, this syntax may require aliasing // on the call-site @@ -1224,9 +1219,8 @@ implements else { List> v = new ArrayList>(getUpsertValues().size()); - for (int i = 0; i < getUpsertValues().size(); i++) { + for (int i = 0; i < getUpsertValues().size(); i++) v.add(getUpsertValues().get(i).as("s" + (i + 1))); - } src = DSL.select(v).asTable("src"); } diff --git a/jOOQ/src/main/java/org/jooq/impl/RowCondition.java b/jOOQ/src/main/java/org/jooq/impl/RowCondition.java index 625a184474..12bf258e5b 100644 --- a/jOOQ/src/main/java/org/jooq/impl/RowCondition.java +++ b/jOOQ/src/main/java/org/jooq/impl/RowCondition.java @@ -115,11 +115,11 @@ final class RowCondition extends AbstractCondition { // Regular comparison predicate emulation if ((comparator == EQUALS || comparator == NOT_EQUALS) && EMULATE_EQ_AND_NE.contains(dialect.family())) { - List conditions = new ArrayList(left.fields().length); Field[] leftFields = left.fields(); Field[] rightFields = right.fields(); + List conditions = new ArrayList(leftFields.length); for (int i = 0; i < leftFields.length; i++) conditions.add(leftFields[i].equal((Field) rightFields[i])); diff --git a/jOOQ/src/main/java/org/jooq/impl/RowIsNull.java b/jOOQ/src/main/java/org/jooq/impl/RowIsNull.java index 948f25e40f..993bed0dc1 100644 --- a/jOOQ/src/main/java/org/jooq/impl/RowIsNull.java +++ b/jOOQ/src/main/java/org/jooq/impl/RowIsNull.java @@ -109,9 +109,10 @@ final class RowIsNull extends AbstractCondition { // CUBRID 9.0.0 and HSQLDB have buggy implementations of the NULL predicate. // Informix doesn't implement the RVE IS NULL predicate. if (EMULATE_NULL.contains(configuration.family())) { - List conditions = new ArrayList(row.fields().length); + Field[] fields = row.fields(); + List conditions = new ArrayList(fields.length); - for (Field field : row.fields()) + for (Field field : fields) conditions.add(isNull ? field.isNull() : field.isNotNull()); Condition result = DSL.and(conditions); diff --git a/jOOQ/src/main/java/org/jooq/impl/RowSubqueryCondition.java b/jOOQ/src/main/java/org/jooq/impl/RowSubqueryCondition.java index 82dbda7c77..df48a85091 100644 --- a/jOOQ/src/main/java/org/jooq/impl/RowSubqueryCondition.java +++ b/jOOQ/src/main/java/org/jooq/impl/RowSubqueryCondition.java @@ -47,7 +47,7 @@ import static org.jooq.Comparator.NOT_IN; import static org.jooq.SQLDialect.H2; import static org.jooq.SQLDialect.HSQLDB; import static org.jooq.SQLDialect.MARIADB; -import static org.jooq.SQLDialect.*; +import static org.jooq.SQLDialect.MYSQL; // ... import static org.jooq.SQLDialect.POSTGRES; // ... @@ -57,12 +57,9 @@ import static org.jooq.impl.DSL.name; import static org.jooq.impl.DSL.notExists; import static org.jooq.impl.DSL.row; import static org.jooq.impl.DSL.select; -import static org.jooq.impl.Tools.EMPTY_STRING; import static org.jooq.impl.Tools.DataKey.DATA_ROW_VALUE_EXPRESSION_PREDICATE_SUBQUERY; -import java.util.ArrayList; import java.util.EnumSet; -import java.util.List; import org.jooq.Clause; import org.jooq.Comparator; @@ -153,13 +150,13 @@ final class RowSubqueryCondition extends AbstractCondition { else { String table = render == null ? "t" : render.nextAlias(); - List names = new ArrayList(left.size()); + String[] names = new String[left.size()]; for (int i = 0; i < left.size(); i++) - names.add(table + "_" + i); + names[i] = table + "_" + i; - Field[] fields = new Field[names.size()]; + Field[] fields = new Field[names.length]; for (int i = 0; i < fields.length; i++) - fields[i] = field(name(table, names.get(i))); + fields[i] = field(name(table, names[i])); Condition condition; switch (comparator) { @@ -189,7 +186,7 @@ final class RowSubqueryCondition extends AbstractCondition { } Select subselect = - select().from(right.asTable(table, names.toArray(EMPTY_STRING))) + select().from(right.asTable(table, names)) .where(condition); switch (comparator) { diff --git a/jOOQ/src/main/java/org/jooq/impl/Tools.java b/jOOQ/src/main/java/org/jooq/impl/Tools.java index f9022076fc..7b2b7b8e45 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Tools.java +++ b/jOOQ/src/main/java/org/jooq/impl/Tools.java @@ -1421,12 +1421,13 @@ final class Tools { * values created from the argument objects. */ static final List> fields(T[] values) { - int length = values == null ? 0 : values.length; - List> result = new ArrayList>(length); + if (values == null) + return new ArrayList>(); - for (int i = 0; i < length; i++) { + List> result = new ArrayList>(values.length); + + for (int i = 0; i < values.length; i++) result.add(field(values[i])); - } return result; } @@ -1440,12 +1441,13 @@ final class Tools { * values created from the argument objects. */ static final List> fields(Object[] values, Field field) { - int length = values == null || field == null ? 0 : values.length; - List> result = new ArrayList>(length); + if (values == null || field == null) + return new ArrayList>(); - for (int i = 0; i < length; i++) { + List> result = new ArrayList>(values.length); + + for (int i = 0; i < values.length; i++) result.add(field(values[i], field)); - } return result; } @@ -1459,12 +1461,14 @@ final class Tools { * values created from the argument objects. */ static final List> fields(Object[] values, Field[] fields) { - int length = values == null || fields == null ? 0 : Math.min(values.length, fields.length); + if (values == null || fields == null) + return new ArrayList>(); + + int length = Math.min(values.length, fields.length); List> result = new ArrayList>(length); - for (int i = 0; i < length; i++) { + for (int i = 0; i < length; i++) result.add(field(values[i], fields[i])); - } return result; } @@ -1478,12 +1482,13 @@ final class Tools { * values created from the argument objects. */ static final List> fields(Object[] values, Class type) { - int length = values == null || type == null ? 0 : values.length; - List> result = new ArrayList>(length); + if (values == null || type == null) + return new ArrayList>(); - for (int i = 0; i < length; i++) { + List> result = new ArrayList>(values.length); + + for (int i = 0; i < values.length; i++) result.add(field(values[i], type)); - } return result; } @@ -1497,12 +1502,14 @@ final class Tools { * values created from the argument objects. */ static final List> fields(Object[] values, Class[] types) { - int length = values == null || types == null ? 0 : Math.min(values.length, types.length); + if (values == null || types == null) + return new ArrayList>(); + + int length = Math.min(values.length, types.length); List> result = new ArrayList>(length); - for (int i = 0; i < length; i++) { + for (int i = 0; i < length; i++) result.add(field(values[i], types[i])); - } return result; } @@ -1516,12 +1523,13 @@ final class Tools { * values created from the argument objects. */ static final List> fields(Object[] values, DataType type) { - int length = values == null || type == null ? 0 : values.length; - List> result = new ArrayList>(length); + if (values == null || type == null) + return new ArrayList>(); - for (int i = 0; i < length; i++) { + List> result = new ArrayList>(values.length); + + for (int i = 0; i < values.length; i++) result.add(field(values[i], type)); - } return result; } @@ -1535,23 +1543,26 @@ final class Tools { * values created from the argument objects. */ static final List> fields(Object[] values, DataType[] types) { - int length = values == null || types == null ? 0 : Math.min(values.length, types.length); + if (values == null || types == null) + return new ArrayList>(); + + int length = Math.min(values.length, types.length); List> result = new ArrayList>(length); - for (int i = 0; i < length; i++) { + for (int i = 0; i < length; i++) result.add(field(values[i], types[i])); - } return result; } static final List> inline(T[] values) { - int length = values == null ? 0 : values.length; - List> result = new ArrayList>(length); + if (values == null) + return new ArrayList>(); - for (int i = 0; i < length; i++) { + List> result = new ArrayList>(values.length); + + for (int i = 0; i < values.length; i++) result.add(DSL.inline(values[i])); - } return result; }