From 738e0adc850a41d8db323cd16e223052677be0e3 Mon Sep 17 00:00:00 2001 From: Lukas Eder Date: Sat, 6 Apr 2013 18:17:35 +0200 Subject: [PATCH] [#2379] Replace 3.0-RC1 Executor type by a contextual DSL type constructed from Factory.using() - Step 2 - Re-introduce "FactoryOperations", named ContextDSL - Let Executor implement ContextDSL --- .../{Executor.xtend => ContextDSL.xtend} | 76 +- .../src/org/jooq/xtend/GenerateAll.xtend | 2 +- jOOQ/src/main/java/org/jooq/ContextDSL.java | 4731 +++++++++++++++++ .../src/main/java/org/jooq/impl/Executor.java | 4341 +-------------- 4 files changed, 4993 insertions(+), 4157 deletions(-) rename jOOQ-tools/src/org/jooq/xtend/{Executor.xtend => ContextDSL.xtend} (77%) create mode 100644 jOOQ/src/main/java/org/jooq/ContextDSL.java diff --git a/jOOQ-tools/src/org/jooq/xtend/Executor.xtend b/jOOQ-tools/src/org/jooq/xtend/ContextDSL.xtend similarity index 77% rename from jOOQ-tools/src/org/jooq/xtend/Executor.xtend rename to jOOQ-tools/src/org/jooq/xtend/ContextDSL.xtend index 37bf8a7361..c7e55fc562 100644 --- a/jOOQ-tools/src/org/jooq/xtend/Executor.xtend +++ b/jOOQ-tools/src/org/jooq/xtend/ContextDSL.xtend @@ -41,18 +41,19 @@ package org.jooq.xtend */ import org.jooq.Constants -class Executor extends Generators { +class ContextDSL extends Generators { def static void main(String[] args) { - val executor = new Executor(); - executor.generateSelect(); - executor.generateSelectDistinct(); - executor.generateInsert(); - executor.generateMerge(); + val contextDSL = new ContextDSL(); + contextDSL.generateSelect(); + contextDSL.generateSelectDistinct(); + contextDSL.generateInsert(); + contextDSL.generateMerge(); } def generateSelect() { - val out = new StringBuilder(); + val outImpl = new StringBuilder(); + val outAPI = new StringBuilder(); for (degree : (1..Constants::MAX_ROW_DEGREE)) { var fieldOrRow = "Row" + degree; @@ -61,7 +62,7 @@ class Executor extends Generators { fieldOrRow = "Field"; } - out.append(''' + outAPI.append(''' /** * Create a new DSL select statement. @@ -92,17 +93,26 @@ class Executor extends Generators { */ «generatedMethod» @Support + <«TN(degree)»> SelectSelectStep> select(«Field_TN_fieldn(degree)»); + '''); + + outImpl.append(''' + + «generatedMethod» + @Override public final <«TN(degree)»> SelectSelectStep> select(«Field_TN_fieldn(degree)») { return (SelectSelectStep) select(new Field[] { «fieldn(degree)» }); } '''); } - insert("org.jooq.impl.Executor", out, "select"); + insert("org.jooq.ContextDSL", outAPI, "select"); + insert("org.jooq.impl.Executor", outImpl, "select"); } def generateSelectDistinct() { - val out = new StringBuilder(); + val outImpl = new StringBuilder(); + val outAPI = new StringBuilder(); for (degree : (1..Constants::MAX_ROW_DEGREE)) { var fieldOrRow = "Row" + degree; @@ -111,7 +121,7 @@ class Executor extends Generators { fieldOrRow = "Field"; } - out.append(''' + outAPI.append(''' /** * Create a new DSL select statement. @@ -142,20 +152,29 @@ class Executor extends Generators { */ «generatedMethod» @Support + <«TN(degree)»> SelectSelectStep> selectDistinct(«Field_TN_fieldn(degree)»); + '''); + + outImpl.append(''' + + «generatedMethod» + @Override public final <«TN(degree)»> SelectSelectStep> selectDistinct(«Field_TN_fieldn(degree)») { return (SelectSelectStep) selectDistinct(new Field[] { «fieldn(degree)» }); } '''); } - insert("org.jooq.impl.Executor", out, "selectDistinct"); + insert("org.jooq.ContextDSL", outAPI, "selectDistinct"); + insert("org.jooq.impl.Executor", outImpl, "selectDistinct"); } def generateInsert() { - val out = new StringBuilder(); + val outImpl = new StringBuilder(); + val outAPI = new StringBuilder(); for (degree : (1..Constants::MAX_ROW_DEGREE)) { - out.append(''' + outAPI.append(''' /** * Create a new DSL insert statement. @@ -174,20 +193,29 @@ class Executor extends Generators { */ «generatedMethod» @Support + InsertValuesStep«degree» insertInto(Table into, «Field_TN_fieldn(degree)»); + '''); + + outImpl.append(''' + + «generatedMethod» + @Override public final InsertValuesStep«degree» insertInto(Table into, «Field_TN_fieldn(degree)») { - return new InsertImpl(this, into, Arrays.asList(new Field[] { «fieldn(degree)» })); + return new InsertImpl(configuration, into, Arrays.asList(new Field[] { «fieldn(degree)» })); } '''); } - insert("org.jooq.impl.Executor", out, "insert"); + insert("org.jooq.ContextDSL", outAPI, "insert"); + insert("org.jooq.impl.Executor", outImpl, "insert"); } def generateMerge() { - val out = new StringBuilder(); + val outImpl = new StringBuilder(); + val outAPI = new StringBuilder(); for (degree : (1..Constants::MAX_ROW_DEGREE)) { - out.append(''' + outAPI.append(''' /** * Create a new DSL merge statement (H2-specific syntax) @@ -211,12 +239,20 @@ class Executor extends Generators { */ «generatedMethod» @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep«degree» mergeInto(Table table, «Field_TN_fieldn(degree)»); + '''); + + outImpl.append(''' + + «generatedMethod» + @Override public final MergeKeyStep«degree» mergeInto(Table table, «Field_TN_fieldn(degree)») { - return new MergeImpl(this, table, Arrays.asList(«fieldn(degree)»)); + return new MergeImpl(configuration, table, Arrays.asList(«fieldn(degree)»)); } '''); } - insert("org.jooq.impl.Executor", out, "merge"); + insert("org.jooq.ContextDSL", outAPI, "merge"); + insert("org.jooq.impl.Executor", outImpl, "merge"); } } \ No newline at end of file diff --git a/jOOQ-tools/src/org/jooq/xtend/GenerateAll.xtend b/jOOQ-tools/src/org/jooq/xtend/GenerateAll.xtend index 4ead5b0012..c603063907 100644 --- a/jOOQ-tools/src/org/jooq/xtend/GenerateAll.xtend +++ b/jOOQ-tools/src/org/jooq/xtend/GenerateAll.xtend @@ -4,7 +4,7 @@ class GenerateAll { def static void main(String[] args) { BetweenAndSteps::main(args); Conversions::main(args); - Executor::main(args); + ContextDSL::main(args); Factory::main(args); InsertDSL::main(args); MergeDSL::main(args); diff --git a/jOOQ/src/main/java/org/jooq/ContextDSL.java b/jOOQ/src/main/java/org/jooq/ContextDSL.java new file mode 100644 index 0000000000..06474e4771 --- /dev/null +++ b/jOOQ/src/main/java/org/jooq/ContextDSL.java @@ -0,0 +1,4731 @@ +/** + * Copyright (c) 2009-2013, Lukas Eder, lukas.eder@gmail.com + * All rights reserved. + * + * This software is licensed to you under the Apache License, Version 2.0 + * (the "License"); You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * . Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * . Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * . Neither the name "jOOQ" nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +package org.jooq; + +import static org.jooq.SQLDialect.ASE; +import static org.jooq.SQLDialect.CUBRID; +import static org.jooq.SQLDialect.DB2; +import static org.jooq.SQLDialect.DERBY; +import static org.jooq.SQLDialect.FIREBIRD; +import static org.jooq.SQLDialect.H2; +import static org.jooq.SQLDialect.HSQLDB; +import static org.jooq.SQLDialect.INGRES; +import static org.jooq.SQLDialect.MYSQL; +import static org.jooq.SQLDialect.ORACLE; +import static org.jooq.SQLDialect.POSTGRES; +import static org.jooq.SQLDialect.SQLITE; +import static org.jooq.SQLDialect.SQLSERVER; +import static org.jooq.SQLDialect.SYBASE; + +import java.math.BigInteger; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.Statement; +import java.util.Collection; +import java.util.List; +import java.util.Map; + +import javax.annotation.Generated; + +import org.jooq.conf.Settings; +import org.jooq.conf.StatementType; +import org.jooq.exception.DataAccessException; +import org.jooq.exception.InvalidResultException; +import org.jooq.exception.MappingException; +import org.jooq.impl.Executor; +import org.jooq.impl.Factory; + +/** + * A contextual DSL providing "attached" implementations to the + * org.jooq interfaces. + *

+ * Apart from the {@link Factory}, this contextual DSL is the main entry point + * for client code, to access jOOQ classes and functionality that are related to + * {@link Query} execution. Unlike objects created through the + * Factory, objects created from a ContextDSL will be + * "attached" to the ContextDSL's {@link #configuration()}, such + * that they can be executed immediately in a fluent style. An example is given + * here: + *

+ * 

+ * ContextDSL create = Factory.using(connection, dialect);
+ *
+ * // Immediately fetch results after constructing a query
+ * create.selectFrom(MY_TABLE).where(MY_TABLE.ID.eq(1)).fetch();
+ *
+ * // The above is equivalent to this "non-fluent" style
+ * create.fetch(Factory.selectFrom(MY_TABLE).where(MY_TABLE.ID.eq(1)));
+ *
+ *

+ * The Factory provides convenient constructors to create a + * {@link Configuration}, which will be shared among all Query + * objects thus created. Optionally, you can pass a reusable + * Configuration to the {@link Factory#using(Configuration)} + * constructor. Please consider thread-safety concerns documented in + * {@link Configuration}, should you want to reuse the same + * Configuration instance in various threads and / or transactions. + * + * @see Factory + * @see Configuration + * @author Lukas Eder + */ +public interface ContextDSL { + + // ------------------------------------------------------------------------- + // XXX Configuration API + // ------------------------------------------------------------------------- + + /** + * The Configuration referenced from this + * ContextDSL. + */ + Configuration configuration(); + + /** + * Map a schema to another one. + *

+ * This will map a schema onto another one, depending on configured schema + * mapping in this Executor. If no applicable schema mapping + * can be found, the schema itself is returned. + * + * @param schema A schema + * @return The mapped schema + */ + Schema map(Schema schema); + + /** + * Map a table to another one. + *

+ * This will map a table onto another one, depending on configured table + * mapping in this Executor. If no applicable table mapping can + * be found, the table itself is returned. + * + * @param table A table + * @return The mapped table + */ + Table map(Table table); + + // ------------------------------------------------------------------------- + // XXX Convenience methods accessing the underlying Connection + // ------------------------------------------------------------------------- + + /** + * Access the database meta data. + *

+ * This method returns a wrapper type that gives access to your JDBC + * connection's database meta data. + */ + Meta meta(); + + // ------------------------------------------------------------------------- + // XXX RenderContext and BindContext accessors + // ------------------------------------------------------------------------- + + /** + * Get a new {@link RenderContext} for the context of this executor. + *

+ * This will return an initialised render context as such: + *

    + *
  • + * {@link RenderContext#castMode()} == {@link org.jooq.RenderContext.CastMode#DEFAULT DEFAULT} + *
    • + *
  • {@link RenderContext#declareFields()} == false
    • + *
  • {@link RenderContext#declareTables()} == false
    • + *
  • {@link RenderContext#format()} == false
    • + *
  • {@link RenderContext#inline()} == false
    • + *
  • {@link RenderContext#namedParams()} == false
    • + *
  • {@link RenderContext#qualify()} == true
    • + *
  • {@link RenderContext#subquery()} == false
    • + *
+ */ + RenderContext renderContext(); + + /** + * Render a QueryPart in the context of this executor. + *

+ * This is the same as calling renderContext().render(part) + * + * @param part The {@link QueryPart} to be rendered + * @return The rendered SQL + */ + String render(QueryPart part); + + /** + * Render a QueryPart in the context of this executor, rendering bind + * variables as named parameters. + *

+ * This is the same as calling + * renderContext().namedParams(true).render(part) + * + * @param part The {@link QueryPart} to be rendered + * @return The rendered SQL + */ + String renderNamedParams(QueryPart part); + + /** + * Render a QueryPart in the context of this executor, inlining all bind + * variables. + *

+ * This is the same as calling + * renderContext().inline(true).render(part) + * + * @param part The {@link QueryPart} to be rendered + * @return The rendered SQL + */ + String renderInlined(QueryPart part); + + /** + * Retrieve the bind values that will be bound by a given + * QueryPart. + *

+ * The returned List is immutable. To modify bind values, use + * {@link #extractParams(QueryPart)} instead. + */ + List extractBindValues(QueryPart part); + + /** + * Get a Map of named parameters. + *

+ * The Map itself is immutable, but the {@link Param} elements + * allow for modifying bind values on an existing {@link Query} (or any + * other {@link QueryPart}). + *

+ * Bind values created with {@link Factory#val(Object)} will have their bind + * index as name. + * + * @see Param + * @see Factory#param(String, Object) + */ + Map> extractParams(QueryPart part); + + /** + * Get a named parameter from a {@link QueryPart}, provided its name. + *

+ * Bind values created with {@link Factory#val(Object)} will have their bind + * index as name. + * + * @see Param + * @see Factory#param(String, Object) + */ + Param extractParam(QueryPart part, String name); + + /** + * Get a new {@link BindContext} for the context of this executor. + *

+ * This will return an initialised bind context as such: + *

    + *
  • {@link RenderContext#declareFields()} == false
    • + *
  • {@link RenderContext#declareTables()} == false
    • + *
+ *

+ * RenderContext for JOOQ INTERNAL USE only. Avoid referencing it directly + */ + BindContext bindContext(PreparedStatement stmt); + + /** + * Get a new {@link BindContext} for the context of this executor. + *

+ * This will return an initialised bind context as such: + *

    + *
  • {@link RenderContext#declareFields()} == false
    • + *
  • {@link RenderContext#declareTables()} == false
    • + *
+ *

+ * RenderContext for JOOQ INTERNAL USE only. Avoid referencing it directly + */ + int bind(QueryPart part, PreparedStatement stmt); + + // ------------------------------------------------------------------------- + // XXX Attachable and Serializable API + // ------------------------------------------------------------------------- + + /** + * Attach this Executor to some attachables. + */ + void attach(Attachable... attachables); + + /** + * Attach this Executor to some attachables. + */ + void attach(Collection attachables); + + // ------------------------------------------------------------------------- + // XXX Access to the loader API + // ------------------------------------------------------------------------- + + /** + * Create a new Loader object to load data from a CSV or XML + * source. + */ + @Support + > LoaderOptionsStep loadInto(Table table); + + /** + * Create a new query holding plain SQL. There must not be any binding + * variables contained in the SQL. + *

+ * Example: + *

+ * 

+     * String sql = "SET SCHEMA 'abc'";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @return A query wrapping the plain SQL + */ + @Support + Query query(String sql); + + /** + * Create a new query holding plain SQL. There must be as many bind + * variables contained in the SQL, as passed in the bindings parameter. + *

+ * Example: + *

+ * 

+     * String sql = "SET SCHEMA 'abc'";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @param bindings The bindings + * @return A query wrapping the plain SQL + */ + @Support + Query query(String sql, Object... bindings); + + /** + * Create a new query holding plain SQL. + *

+ * Unlike {@link #query(String, Object...)}, the SQL passed to this method + * should not contain any bind variables. Instead, you can pass + * {@link QueryPart} objects to the method which will be rendered at indexed + * locations of your SQL string as such: 

+     * // The following query
+     * query("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
+     *
+     * // Will render this SQL on an Oracle database with RenderNameStyle.QUOTED:
+     * select ?, 'test' from "DUAL"
+     *
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! One way to escape + * literals is to use {@link Factory#name(String...)} and similar methods + * + * @param sql The SQL clause, containing {numbered placeholders} where query + * parts can be injected + * @param parts The {@link QueryPart} objects that are rendered at the + * {numbered placeholder} locations + * @return A query wrapping the plain SQL + */ + @Support + Query query(String sql, QueryPart... parts); + + /** + * Execute a new query holding plain SQL. + *

+ * Example (Postgres): + *

+ * 

+     * String sql = "FETCH ALL IN \"\"";
Example + * (SQLite): + *

+ * 

+     * String sql = "pragma table_info('my_table')";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @return The results from the executed query. This is never + * null, even if the database returns no + * {@link ResultSet} + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Result fetch(String sql) throws DataAccessException; + + /** + * Execute a new query holding plain SQL. + *

+ * There must be as many bind variables contained in the SQL, as passed in + * the bindings parameter + *

+ * Example (Postgres): + *

+ * 

+     * String sql = "FETCH ALL IN \"\"";
Example + * (SQLite): + *

+ * 

+     * String sql = "pragma table_info('my_table')";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @param bindings The bindings + * @return The results from the executed query. This is never + * null, even if the database returns no + * {@link ResultSet} + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Result fetch(String sql, Object... bindings); + + /** + * Execute a new query holding plain SQL. + *

+ * Unlike {@link #fetch(String, Object...)}, the SQL passed to this method + * should not contain any bind variables. Instead, you can pass + * {@link QueryPart} objects to the method which will be rendered at indexed + * locations of your SQL string as such: 

+     * // The following query
+     * fetch("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
+     *
+     * // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
+     * select ?, 'test' from "DUAL"
+     *
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! One way to escape + * literals is to use {@link Factory#name(String...)} and similar methods + * + * @param sql The SQL clause, containing {numbered placeholders} where query + * parts can be injected + * @param parts The {@link QueryPart} objects that are rendered at the + * {numbered placeholder} locations + * @return The results from the executed query + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Result fetch(String sql, QueryPart... parts); + + /** + * Execute a new query holding plain SQL and "lazily" return the generated + * result. + *

+ * The returned {@link Cursor} holds a reference to the executed + * {@link PreparedStatement} and the associated {@link ResultSet}. Data can + * be fetched (or iterated over) lazily, fetching records from the + * {@link ResultSet} one by one. + *

+ * Example (Postgres): + *

+ * 

+     * String sql = "FETCH ALL IN \"\"";
Example + * (SQLite): + *

+ * 

+     * String sql = "pragma table_info('my_table')";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @return The results from the executed query. This is never + * null, even if the database returns no + * {@link ResultSet} + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Cursor fetchLazy(String sql) throws DataAccessException; + + /** + * Execute a new query holding plain SQL and "lazily" return the generated + * result. + *

+ * There must be as many bind variables contained in the SQL, as passed in + * the bindings parameter + *

+ * The returned {@link Cursor} holds a reference to the executed + * {@link PreparedStatement} and the associated {@link ResultSet}. Data can + * be fetched (or iterated over) lazily, fetching records from the + * {@link ResultSet} one by one. + *

+ * Example (Postgres): + *

+ * 

+     * String sql = "FETCH ALL IN \"\"";
Example + * (SQLite): + *

+ * 

+     * String sql = "pragma table_info('my_table')";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @param bindings The bindings + * @return The results from the executed query. This is never + * null, even if the database returns no + * {@link ResultSet} + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Cursor fetchLazy(String sql, Object... bindings) throws DataAccessException; + + /** + * Execute a new query holding plain SQL and "lazily" return the generated + * result. + *

+ * The returned {@link Cursor} holds a reference to the executed + * {@link PreparedStatement} and the associated {@link ResultSet}. Data can + * be fetched (or iterated over) lazily, fetching records from the + * {@link ResultSet} one by one. + *

+ * Unlike {@link #fetchLazy(String, Object...)}, the SQL passed to this + * method should not contain any bind variables. Instead, you can pass + * {@link QueryPart} objects to the method which will be rendered at indexed + * locations of your SQL string as such: 

+     * // The following query
+     * fetchLazy("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
+     *
+     * // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
+     * select ?, 'test' from "DUAL"
+     *
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! One way to escape + * literals is to use {@link Factory#name(String...)} and similar methods + * + * @param sql The SQL clause, containing {numbered placeholders} where query + * parts can be injected + * @param parts The {@link QueryPart} objects that are rendered at the + * {numbered placeholder} locations + * @return The results from the executed query + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Cursor fetchLazy(String sql, QueryPart... parts) throws DataAccessException; + + /** + * Execute a new query holding plain SQL, possibly returning several result + * sets. + *

+ * Example (Sybase ASE): + *

+ * 

+     * String sql = "sp_help 'my_table'";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @return The results from the executed query. This is never + * null, even if the database returns no + * {@link ResultSet} + * @throws DataAccessException if something went wrong executing the query + */ + @Support + List> fetchMany(String sql) throws DataAccessException; + + /** + * Execute a new query holding plain SQL, possibly returning several result + * sets. + *

+ * There must be as many bind variables contained in the SQL, as passed in + * the bindings parameter + *

+ * Example (Sybase ASE): + *

+ * 

+     * String sql = "sp_help 'my_table'";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @param bindings The bindings + * @return The results from the executed query. This is never + * null, even if the database returns no + * {@link ResultSet} + * @throws DataAccessException if something went wrong executing the query + */ + @Support + List> fetchMany(String sql, Object... bindings) throws DataAccessException; + + /** + * Execute a new query holding plain SQL, possibly returning several result + * sets. + *

+ * Unlike {@link #fetchMany(String, Object...)}, the SQL passed to this + * method should not contain any bind variables. Instead, you can pass + * {@link QueryPart} objects to the method which will be rendered at indexed + * locations of your SQL string as such: 

+     * // The following query
+     * fetchMany("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
+     *
+     * // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
+     * select ?, 'test' from "DUAL"
+     *
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! One way to escape + * literals is to use {@link Factory#name(String...)} and similar methods + * + * @param sql The SQL clause, containing {numbered placeholders} where query + * parts can be injected + * @param parts The {@link QueryPart} objects that are rendered at the + * {numbered placeholder} locations + * @return The results from the executed query + * @throws DataAccessException if something went wrong executing the query + */ + @Support + List> fetchMany(String sql, QueryPart... parts) throws DataAccessException; + + /** + * Execute a new query holding plain SQL. + *

+ * Example (Postgres): + *

+ * 

+     * String sql = "FETCH ALL IN \"\"";
Example + * (SQLite): + *

+ * 

+     * String sql = "pragma table_info('my_table')";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @return The results from the executed query. This is never + * null, even if the database returns no + * {@link ResultSet} + * @throws DataAccessException if something went wrong executing the query + * @throws InvalidResultException if the query returned more than one record + */ + @Support + Record fetchOne(String sql) throws DataAccessException, InvalidResultException; + + /** + * Execute a new query holding plain SQL. + *

+ * There must be as many bind variables contained in the SQL, as passed in + * the bindings parameter + *

+ * Example (Postgres): + *

+ * 

+     * String sql = "FETCH ALL IN \"\"";
Example + * (SQLite): + *

+ * 

+     * String sql = "pragma table_info('my_table')";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @param bindings The bindings + * @return The results from the executed query. This may be + * null if the database returned no records + * @throws DataAccessException if something went wrong executing the query + * @throws InvalidResultException if the query returned more than one record + */ + @Support + Record fetchOne(String sql, Object... bindings) throws DataAccessException, InvalidResultException; + + /** + * Execute a new query holding plain SQL. + *

+ * Unlike {@link #fetchOne(String, Object...)}, the SQL passed to this + * method should not contain any bind variables. Instead, you can pass + * {@link QueryPart} objects to the method which will be rendered at indexed + * locations of your SQL string as such: 

+     * // The following query
+     * fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
+     *
+     * // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
+     * select ?, 'test' from "DUAL"
+     *
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! One way to escape + * literals is to use {@link Factory#name(String...)} and similar methods + * + * @param sql The SQL clause, containing {numbered placeholders} where query + * parts can be injected + * @param parts The {@link QueryPart} objects that are rendered at the + * {numbered placeholder} locations + * @return The results from the executed query. This may be + * null if the database returned no records + * @throws DataAccessException if something went wrong executing the query + * @throws InvalidResultException if the query returned more than one record + */ + @Support + Record fetchOne(String sql, QueryPart... parts) throws DataAccessException, InvalidResultException; + + /** + * Execute a query holding plain SQL. + *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @return The results from the executed query + * @throws DataAccessException if something went wrong executing the query + */ + @Support + int execute(String sql) throws DataAccessException; + + /** + * Execute a new query holding plain SQL. + *

+ * There must be as many bind variables contained in the SQL, as passed in + * the bindings parameter + *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @param bindings The bindings + * @return The results from the executed query + * @throws DataAccessException if something went wrong executing the query + */ + @Support + int execute(String sql, Object... bindings) throws DataAccessException; + + /** + * Execute a new query holding plain SQL. + *

+ * Unlike {@link #execute(String, Object...)}, the SQL passed to this method + * should not contain any bind variables. Instead, you can pass + * {@link QueryPart} objects to the method which will be rendered at indexed + * locations of your SQL string as such: 

+     * // The following query
+     * execute("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
+     *
+     * // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
+     * select ?, 'test' from "DUAL"
+     *
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! One way to escape + * literals is to use {@link Factory#name(String...)} and similar methods + * + * @param sql The SQL clause, containing {numbered placeholders} where query + * parts can be injected + * @param parts The {@link QueryPart} objects that are rendered at the + * {numbered placeholder} locations + * @return The results from the executed query + * @throws DataAccessException if something went wrong executing the query + */ + @Support + int execute(String sql, QueryPart... parts) throws DataAccessException; + + /** + * Create a new query holding plain SQL. + *

+ * There must not be any binding variables contained in the SQL + *

+ * Use this method, when you want to take advantage of the many ways to + * fetch results in jOOQ, using {@link ResultQuery}. Some examples: + *

+ * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
{@link ResultQuery#fetchLazy()}Open a cursor and fetch records one by one
{@link ResultQuery#fetchInto(Class)}Fetch records into a custom POJO (optionally annotated with JPA + * annotations)
{@link ResultQuery#fetchInto(RecordHandler)}Fetch records into a custom callback (similar to Spring's RowMapper)
{@link ResultQuery#fetchLater()}Fetch records of a long-running query asynchronously
+ *

+ * Example (Postgres): + *

+ * 

+     * String sql = "FETCH ALL IN \"\"";
Example + * (SQLite): + *

+ * 

+     * String sql = "pragma table_info('my_table')";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @return An executable query + * @throws DataAccessException if something went wrong executing the query + */ + @Support + ResultQuery resultQuery(String sql); + + /** + * Create a new query holding plain SQL. + *

+ * There must be as many bind variables contained in the SQL, as passed in + * the bindings parameter + *

+ * Use this method, when you want to take advantage of the many ways to + * fetch results in jOOQ, using {@link ResultQuery}. Some examples: + *

+ * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
{@link ResultQuery#fetchLazy()}Open a cursor and fetch records one by one
{@link ResultQuery#fetchInto(Class)}Fetch records into a custom POJO (optionally annotated with JPA + * annotations)
{@link ResultQuery#fetchInto(RecordHandler)}Fetch records into a custom callback (similar to Spring's RowMapper)
{@link ResultQuery#fetchLater()}Fetch records of a long-running query asynchronously
+ *

+ * Example (Postgres): + *

+ * 

+     * String sql = "FETCH ALL IN \"\"";
Example + * (SQLite): + *

+ * 

+     * String sql = "pragma table_info('my_table')";
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! + * + * @param sql The SQL + * @param bindings The bindings + * @return A query wrapping the plain SQL + */ + @Support + ResultQuery resultQuery(String sql, Object... bindings); + + /** + * Create a new query holding plain SQL. + *

+ * Unlike {@link #resultQuery(String, Object...)}, the SQL passed to this + * method should not contain any bind variables. Instead, you can pass + * {@link QueryPart} objects to the method which will be rendered at indexed + * locations of your SQL string as such: 

+     * // The following query
+     * resultQuery("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
+     *
+     * // Will render this SQL on an Oracle database with RenderNameStyle.QUOTED:
+     * select ?, 'test' from "DUAL"
+     *
+ *

+ * NOTE: When inserting plain SQL into jOOQ objects, you must + * guarantee syntax integrity. You may also create the possibility of + * malicious SQL injection. Be sure to properly use bind variables and/or + * escape literals when concatenated into SQL clauses! One way to escape + * literals is to use {@link Factory#name(String...)} and similar methods + * + * @param sql The SQL clause, containing {numbered placeholders} where query + * parts can be injected + * @param parts The {@link QueryPart} objects that are rendered at the + * {numbered placeholder} locations + * @return A query wrapping the plain SQL + */ + @Support + ResultQuery resultQuery(String sql, QueryPart... parts); + + // ------------------------------------------------------------------------- + // XXX JDBC convenience methods + // ------------------------------------------------------------------------- + + /** + * Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ + * {@link Result}. + *

+ * After fetching all data, the JDBC ResultSet will be closed. + *

+ * Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a + * time, instead of load the entire ResultSet into a jOOQ + * Result at once. + * + * @param rs The JDBC ResultSet to fetch data from + * @return The resulting jOOQ Result + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Result fetch(ResultSet rs) throws DataAccessException; + + /** + * Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ + * {@link Result}. + *

+ * After fetching all data, the JDBC ResultSet will be closed. + *

+ * Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a + * time, instead of load the entire ResultSet into a jOOQ + * Result at once. + *

+ * The additional fields argument is used by jOOQ to coerce + * field names and data types to the desired output + * + * @param rs The JDBC ResultSet to fetch data from + * @param fields The fields to use in the desired output + * @return The resulting jOOQ Result + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Result fetch(ResultSet rs, Field... fields) throws DataAccessException; + + /** + * Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ + * {@link Result}. + *

+ * After fetching all data, the JDBC ResultSet will be closed. + *

+ * Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a + * time, instead of load the entire ResultSet into a jOOQ + * Result at once. + *

+ * The additional types argument is used by jOOQ to coerce data + * types to the desired output + * + * @param rs The JDBC ResultSet to fetch data from + * @param types The data types to use in the desired output + * @return The resulting jOOQ Result + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Result fetch(ResultSet rs, DataType... types) throws DataAccessException; + + /** + * Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ + * {@link Result}. + *

+ * After fetching all data, the JDBC ResultSet will be closed. + *

+ * Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a + * time, instead of load the entire ResultSet into a jOOQ + * Result at once. + *

+ * The additional types argument is used by jOOQ to coerce data + * types to the desired output + * + * @param rs The JDBC ResultSet to fetch data from + * @param types The data types to use in the desired output + * @return The resulting jOOQ Result + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Result fetch(ResultSet rs, Class... types) throws DataAccessException; + + /** + * Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ + * {@link Record}. + *

+ * This will internally fetch all records and throw an exception if there + * was more than one resulting record. + * + * @param rs The JDBC ResultSet to fetch data from + * @return The resulting jOOQ record + * @throws DataAccessException if something went wrong executing the query + * @throws InvalidResultException if the query returned more than one record + */ + @Support + Record fetchOne(ResultSet rs) throws DataAccessException, InvalidResultException; + + /** + * Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ + * {@link Record}. + *

+ * This will internally fetch all records and throw an exception if there + * was more than one resulting record. + *

+ * The additional fields argument is used by jOOQ to coerce + * field names and data types to the desired output + * + * @param rs The JDBC ResultSet to fetch data from + * @param fields The fields to use in the desired output + * @return The resulting jOOQ record + * @throws DataAccessException if something went wrong executing the query + * @throws InvalidResultException if the query returned more than one record + */ + @Support + Record fetchOne(ResultSet rs, Field... fields) throws DataAccessException, InvalidResultException; + + /** + * Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ + * {@link Record}. + *

+ * This will internally fetch all records and throw an exception if there + * was more than one resulting record. + *

+ * The additional types argument is used by jOOQ to coerce data + * types to the desired output + * + * @param rs The JDBC ResultSet to fetch data from + * @param types The data types to use in the desired output + * @return The resulting jOOQ record + * @throws DataAccessException if something went wrong executing the query + * @throws InvalidResultException if the query returned more than one record + */ + @Support + Record fetchOne(ResultSet rs, DataType... types) throws DataAccessException, InvalidResultException; + + /** + * Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ + * {@link Record}. + *

+ * This will internally fetch all records and throw an exception if there + * was more than one resulting record. + *

+ * The additional types argument is used by jOOQ to coerce data + * types to the desired output + * + * @param rs The JDBC ResultSet to fetch data from + * @param types The data types to use in the desired output + * @return The resulting jOOQ record + * @throws DataAccessException if something went wrong executing the query + * @throws InvalidResultException if the query returned more than one record + */ + @Support + Record fetchOne(ResultSet rs, Class... types) throws DataAccessException, InvalidResultException; + + /** + * Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}. + *

+ * Use {@link #fetch(ResultSet)}, to load the entire ResultSet + * into a jOOQ Result at once. + * + * @param rs The JDBC ResultSet to fetch data from + * @return The resulting jOOQ Result + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Cursor fetchLazy(ResultSet rs) throws DataAccessException; + + /** + * Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}. + *

+ * Use {@link #fetch(ResultSet)}, to load the entire ResultSet + * into a jOOQ Result at once. + *

+ * The additional fields argument is used by jOOQ to coerce + * field names and data types to the desired output + * + * @param rs The JDBC ResultSet to fetch data from + * @param fields The fields to use in the desired output + * @return The resulting jOOQ Result + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Cursor fetchLazy(ResultSet rs, Field... fields) throws DataAccessException; + + /** + * Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}. + *

+ * Use {@link #fetch(ResultSet)}, to load the entire ResultSet + * into a jOOQ Result at once. + *

+ * The additional types argument is used by jOOQ to coerce data + * types to the desired output + * + * @param rs The JDBC ResultSet to fetch data from + * @param types The data types to use in the desired output + * @return The resulting jOOQ Result + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Cursor fetchLazy(ResultSet rs, DataType... types) throws DataAccessException; + + /** + * Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}. + *

+ * Use {@link #fetch(ResultSet)}, to load the entire ResultSet + * into a jOOQ Result at once. + *

+ * The additional types argument is used by jOOQ to coerce data + * types to the desired output + * + * @param rs The JDBC ResultSet to fetch data from + * @param types The data types to use in the desired output + * @return The resulting jOOQ Result + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Cursor fetchLazy(ResultSet rs, Class... types) throws DataAccessException; + + /** + * Fetch all data from a formatted string. + *

+ * The supplied string is supposed to be formatted in the following, + * human-readable way: 

+     * COL1  COL2   COL3 containing whitespace
+     * ----- ----   --------------------------
+     * val1  1      some text
+     * val2   2      more text
+     *
This method will decode the above formatted string + * according to the following rules: + *
    + *
  • The number of columns is defined by the number of dash groups in the + * second line
    • + *
  • The column types are VARCHAR(N) where + * N = number of dashes per dash group
    • + *
  • The column names are defined by the trimmed text contained in the + * first row
    • + *
  • The data is defined by the trimmed text contained in the subsequent + * rows
    • + *
+ *

+ * This is the same as calling {@link #fetchFromTXT(String, String)} with + * "{null}" as nullLiteral + *

+ * A future version of jOOQ will also support the inverse operation of + * {@link Result#format()} through this method + * + * @param string The formatted string + * @return The transformed result + * @see #fetchFromTXT(String, String) + * @throws DataAccessException If the supplied string does not adhere to the + * above format rules. + */ + @Support + Result fetchFromTXT(String string) throws DataAccessException; + + /** + * Fetch all data from a formatted string. + *

+ * The supplied string is supposed to be formatted in the following, + * human-readable way: 

+     * COL1  COL2   COL3 containing whitespace
+     * ----- ----   --------------------------
+     * val1  1      some text
+     * val2   2      more text
+     *
This method will decode the above formatted string + * according to the following rules: + *
    + *
  • The number of columns is defined by the number of dash groups in the + * second line
    • + *
  • The column types are VARCHAR(N) where + * N = number of dashes per dash group
    • + *
  • The column names are defined by the trimmed text contained in the + * first row
    • + *
  • The data is defined by the trimmed text contained in the subsequent + * rows
    • + *
+ *

+ * A future version of jOOQ will also support the inverse operation of + * {@link Result#format()} through this method + * + * @param string The formatted string + * @param nullLiteral The string literal to be used as null + * value. + * @return The transformed result + * @throws DataAccessException If the supplied string does not adhere to the + * above format rules. + */ + @Support + Result fetchFromTXT(String string, String nullLiteral) throws DataAccessException; + + /** + * Fetch all data from a CSV string. + *

+ * This is the same as calling fetchFromCSV(string, ',') and + * the inverse of calling {@link Result#formatCSV()}. The first row of the + * CSV data is required to hold field name information. Subsequent rows may + * contain data, which is interpreted as {@link String}. Use the various + * conversion methods to retrieve other data types from the + * Result: + *

    + *
  • {@link Result#getValues(Field, Class)}
    • + *
  • {@link Result#getValues(int, Class)}
    • + *
  • {@link Result#getValues(String, Class)}
    • + *
  • {@link Result#getValues(Field, Converter)}
    • + *
  • {@link Result#getValues(int, Converter)}
    • + *
  • {@link Result#getValues(String, Converter)}
    • + *
+ *

+ * Missing values result in null. Empty values result in empty + * Strings + * + * @param string The CSV string + * @return The transformed result + * @throws DataAccessException If anything went wrong parsing the CSV file + * @see #fetchFromCSV(String, char) + */ + @Support + Result fetchFromCSV(String string) throws DataAccessException; + + /** + * Fetch all data from a CSV string. + *

+ * This is inverse of calling {@link Result#formatCSV(char)}. The first row + * of the CSV data is required to hold field name information. Subsequent + * rows may contain data, which is interpreted as {@link String}. Use the + * various conversion methods to retrieve other data types from the + * Result: + *

    + *
  • {@link Result#getValues(Field, Class)}
    • + *
  • {@link Result#getValues(int, Class)}
    • + *
  • {@link Result#getValues(String, Class)}
    • + *
  • {@link Result#getValues(Field, Converter)}
    • + *
  • {@link Result#getValues(int, Converter)}
    • + *
  • {@link Result#getValues(String, Converter)}
    • + *
+ *

+ * Missing values result in null. Empty values result in empty + * Strings + * + * @param string The CSV string + * @param delimiter The delimiter to expect between records + * @return The transformed result + * @throws DataAccessException If anything went wrong parsing the CSV file + * @see #fetchFromCSV(String) + * @see #fetchFromStringData(List) + */ + @Support + Result fetchFromCSV(String string, char delimiter) throws DataAccessException; + + /** + * Fetch all data from a list of strings. + *

+ * This is used by methods such as + *

    + *
  • {@link #fetchFromCSV(String)}
    • + *
  • {@link #fetchFromTXT(String)}
    • + *
+ * The first element of the argument list should contain column names. + * Subsequent elements contain actual data. The degree of all arrays + * contained in the argument should be the same, although this is not a + * requirement. jOOQ will ignore excess data, and fill missing data with + * null. + * + * @param data The data to be transformed into a Result + * @return The transformed result + * @see #fetchFromStringData(List) + */ + Result fetchFromStringData(String[]... data); + + /** + * Fetch all data from a list of strings. + *

+ * This is used by methods such as + *

    + *
  • {@link #fetchFromCSV(String)}
    • + *
  • {@link #fetchFromTXT(String)}
    • + *
+ * The first element of the argument list should contain column names. + * Subsequent elements contain actual data. The degree of all arrays + * contained in the argument should be the same, although this is not a + * requirement. jOOQ will ignore excess data, and fill missing data with + * null. + * + * @param data The data to be transformed into a Result + * @return The transformed result + */ + Result fetchFromStringData(List data); + + // ------------------------------------------------------------------------- + // XXX Global Query factory + // ------------------------------------------------------------------------- + + /** + * Create a new DSL select statement. + *

+ * Example: 

+     * SELECT * FROM [table] WHERE [conditions] ORDER BY [ordering] LIMIT [limit clause]
+     *
+ */ + @Support + SelectWhereStep selectFrom(Table table); + + /** + * Create a new DSL select statement. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Collection)} instead. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.select(fields)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#select(Collection) + */ + @Support + SelectSelectStep select(Collection> fields); + + /** + * Create a new DSL select statement. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field...)} instead. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.select(field1, field2)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2)
+     *       .execute();
+     *
+ * + * @see Factory#select(Field...) + */ + @Support + SelectSelectStep select(Field... fields); + + // [jooq-tools] START [select] + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Field#in(Select)}, {@link Field#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row2#in(Select)}, {@link Row2#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row3#in(Select)}, {@link Row3#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row4#in(Select)}, {@link Row4#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, field4)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row5#in(Select)}, {@link Row5#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, field4, field5)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row6#in(Select)}, {@link Row6#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field5, field6)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row7#in(Select)}, {@link Row7#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field6, field7)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row8#in(Select)}, {@link Row8#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field7, field8)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row9#in(Select)}, {@link Row9#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field8, field9)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row10#in(Select)}, {@link Row10#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field9, field10)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row11#in(Select)}, {@link Row11#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field10, field11)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row12#in(Select)}, {@link Row12#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field11, field12)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row13#in(Select)}, {@link Row13#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field12, field13)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row14#in(Select)}, {@link Row14#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field13, field14)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row15#in(Select)}, {@link Row15#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field14, field15)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row16#in(Select)}, {@link Row16#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field15, field16)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row17#in(Select)}, {@link Row17#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field16, field17)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row18#in(Select)}, {@link Row18#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field17, field18)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row19#in(Select)}, {@link Row19#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field18, field19)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row20#in(Select)}, {@link Row20#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field19, field20)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row21#in(Select)}, {@link Row21#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field20, field21)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #select(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row22#in(Select)}, {@link Row22#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.select(field1, field2, field3, .., field21, field22)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21, Field field22); + +// [jooq-tools] END [select] + + /** + * Create a new DSL select statement. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Collection)} instead. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.selectDistinct(fields)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Collection) + */ + @Support + SelectSelectStep selectDistinct(Collection> fields); + + /** + * Create a new DSL select statement. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field...)} instead. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.selectDistinct(field1, field2)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + */ + @Support + SelectSelectStep selectDistinct(Field... fields); + + // [jooq-tools] START [selectDistinct] + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Field#in(Select)}, {@link Field#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row2#in(Select)}, {@link Row2#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row3#in(Select)}, {@link Row3#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row4#in(Select)}, {@link Row4#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, field4)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row5#in(Select)}, {@link Row5#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, field4, field5)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row6#in(Select)}, {@link Row6#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field5, field6)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row7#in(Select)}, {@link Row7#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field6, field7)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row8#in(Select)}, {@link Row8#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field7, field8)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row9#in(Select)}, {@link Row9#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field8, field9)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row10#in(Select)}, {@link Row10#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field9, field10)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row11#in(Select)}, {@link Row11#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field10, field11)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row12#in(Select)}, {@link Row12#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field11, field12)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row13#in(Select)}, {@link Row13#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field12, field13)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row14#in(Select)}, {@link Row14#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field13, field14)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row15#in(Select)}, {@link Row15#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field14, field15)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row16#in(Select)}, {@link Row16#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field15, field16)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row17#in(Select)}, {@link Row17#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field16, field17)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row18#in(Select)}, {@link Row18#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field17, field18)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row19#in(Select)}, {@link Row19#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field18, field19)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row20#in(Select)}, {@link Row20#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field19, field20)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row21#in(Select)}, {@link Row21#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field20, field21)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21); + + /** + * Create a new DSL select statement. + *

+ * This is the same as {@link #selectDistinct(Field...)}, except that it + * declares additional record-level typesafety, which is needed by + * {@link Row22#in(Select)}, {@link Row22#equal(Select)} and other predicate + * building methods taking subselect arguments. + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.selectDistinct(field1, field2, field3, .., field21, field22)
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectDistinct(Field...) + * @see #selectDistinct(Field...) + */ + @Generated("This method was generated using jOOQ-tools") + @Support + SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21, Field field22); + +// [jooq-tools] END [selectDistinct] + + /** + * Create a new DSL select statement for constant 0 literal + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectZero()} instead. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.selectZero()
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#zero() + * @see Factory#selectZero() + */ + @Support + SelectSelectStep> selectZero(); + + /** + * Create a new DSL select statement for constant 1 literal + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectOne()} instead. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.selectOne()
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#one() + * @see Factory#selectOne() + */ + @Support + SelectSelectStep> selectOne(); + + /** + * Create a new DSL select statement for COUNT(*) + *

+ * This creates an attached, renderable and executable SELECT + * statement from this {@link Executor}. If you don't need to render or + * execute this SELECT statement (e.g. because you want to + * create a subselect), consider using the static + * {@link Factory#selectCount()} instead. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.selectCount()
+     *       .from(table1)
+     *       .join(table2).on(field1.equal(field2))
+     *       .where(field1.greaterThan(100))
+     *       .orderBy(field2);
+     *
+ * + * @see Factory#selectCount() + */ + @Support + SelectSelectStep> selectCount(); + + /** + * Create a new {@link SelectQuery} + */ + @Support + SelectQuery selectQuery(); + + /** + * Create a new {@link SelectQuery} + * + * @param table The table to select data from + * @return The new {@link SelectQuery} + */ + @Support + SelectQuery selectQuery(TableLike table); + + /** + * Create a new {@link InsertQuery} + * + * @param into The table to insert data into + * @return The new {@link InsertQuery} + */ + @Support + InsertQuery insertQuery(Table into); + + /** + * Create a new DSL insert statement. This type of insert may feel more + * convenient to some users, as it uses the UPDATE statement's + * SET a = b syntax. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.insertInto(table)
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .newRecord()
+     *       .set(field1, value3)
+     *       .set(field2, value4)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Support + InsertSetStep insertInto(Table into); + + // [jooq-tools] START [insert] + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1)
+     *       .values(field1)
+     *       .values(field1)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep1 insertInto(Table into, Field field1); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2)
+     *       .values(field1, field2)
+     *       .values(field1, field2)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep2 insertInto(Table into, Field field1, Field field2); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3)
+     *       .values(field1, field2, field3)
+     *       .values(field1, field2, field3)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep3 insertInto(Table into, Field field1, Field field2, Field field3); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, field4)
+     *       .values(field1, field2, field3, field4)
+     *       .values(field1, field2, field3, field4)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep4 insertInto(Table into, Field field1, Field field2, Field field3, Field field4); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, field4, field5)
+     *       .values(field1, field2, field3, field4, field5)
+     *       .values(field1, field2, field3, field4, field5)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep5 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field5, field6)
+     *       .values(valueA1, valueA2, valueA3, .., valueA5, valueA6)
+     *       .values(valueB1, valueB2, valueB3, .., valueB5, valueB6)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep6 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field6, field7)
+     *       .values(valueA1, valueA2, valueA3, .., valueA6, valueA7)
+     *       .values(valueB1, valueB2, valueB3, .., valueB6, valueB7)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep7 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field7, field8)
+     *       .values(valueA1, valueA2, valueA3, .., valueA7, valueA8)
+     *       .values(valueB1, valueB2, valueB3, .., valueB7, valueB8)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep8 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field8, field9)
+     *       .values(valueA1, valueA2, valueA3, .., valueA8, valueA9)
+     *       .values(valueB1, valueB2, valueB3, .., valueB8, valueB9)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep9 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field9, field10)
+     *       .values(valueA1, valueA2, valueA3, .., valueA9, valueA10)
+     *       .values(valueB1, valueB2, valueB3, .., valueB9, valueB10)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep10 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field10, field11)
+     *       .values(valueA1, valueA2, valueA3, .., valueA10, valueA11)
+     *       .values(valueB1, valueB2, valueB3, .., valueB10, valueB11)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep11 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field11, field12)
+     *       .values(valueA1, valueA2, valueA3, .., valueA11, valueA12)
+     *       .values(valueB1, valueB2, valueB3, .., valueB11, valueB12)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep12 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field12, field13)
+     *       .values(valueA1, valueA2, valueA3, .., valueA12, valueA13)
+     *       .values(valueB1, valueB2, valueB3, .., valueB12, valueB13)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep13 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field13, field14)
+     *       .values(valueA1, valueA2, valueA3, .., valueA13, valueA14)
+     *       .values(valueB1, valueB2, valueB3, .., valueB13, valueB14)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep14 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field14, field15)
+     *       .values(valueA1, valueA2, valueA3, .., valueA14, valueA15)
+     *       .values(valueB1, valueB2, valueB3, .., valueB14, valueB15)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep15 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field15, field16)
+     *       .values(valueA1, valueA2, valueA3, .., valueA15, valueA16)
+     *       .values(valueB1, valueB2, valueB3, .., valueB15, valueB16)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep16 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field16, field17)
+     *       .values(valueA1, valueA2, valueA3, .., valueA16, valueA17)
+     *       .values(valueB1, valueB2, valueB3, .., valueB16, valueB17)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep17 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field17, field18)
+     *       .values(valueA1, valueA2, valueA3, .., valueA17, valueA18)
+     *       .values(valueB1, valueB2, valueB3, .., valueB17, valueB18)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep18 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field18, field19)
+     *       .values(valueA1, valueA2, valueA3, .., valueA18, valueA19)
+     *       .values(valueB1, valueB2, valueB3, .., valueB18, valueB19)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep19 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field19, field20)
+     *       .values(valueA1, valueA2, valueA3, .., valueA19, valueA20)
+     *       .values(valueB1, valueB2, valueB3, .., valueB19, valueB20)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep20 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field20, field21)
+     *       .values(valueA1, valueA2, valueA3, .., valueA20, valueA21)
+     *       .values(valueB1, valueB2, valueB3, .., valueB20, valueB21)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep21 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = new Executor();
+     *
+     * create.insertInto(table, field1, field2, field3, .., field21, field22)
+     *       .values(valueA1, valueA2, valueA3, .., valueA21, valueA22)
+     *       .values(valueB1, valueB2, valueB3, .., valueB21, valueB22)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support + InsertValuesStep22 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21, Field field22); + +// [jooq-tools] END [insert] + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.insertInto(table, field1, field2)
+     *       .values(value1, value2)
+     *       .values(value3, value4)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Support + InsertValuesStepN insertInto(Table into, Field... fields); + + /** + * Create a new DSL insert statement. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.insertInto(table, field1, field2)
+     *       .values(value1, value2)
+     *       .values(value3, value4)
+     *       .onDuplicateKeyUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .execute();
+     *
+ */ + @Support + InsertValuesStepN insertInto(Table into, Collection> fields); + + /** + * Create a new {@link UpdateQuery} + * + * @param table The table to update data into + * @return The new {@link UpdateQuery} + */ + @Support + UpdateQuery updateQuery(Table table); + + /** + * Create a new DSL update statement. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.update(table)
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .where(field1.greaterThan(100))
+     *       .execute();
+     *
+ *

+ * Note that some databases support table expressions more complex than + * simple table references. In CUBRID and MySQL, for instance, you can write + * 

+     * create.update(t1.join(t2).on(t1.id.eq(t2.id)))
+     *       .set(t1.value, value1)
+     *       .set(t2.value, value2)
+     *       .where(t1.id.eq(10))
+     *       .execute();
+     *
+ */ + @Support + UpdateSetFirstStep update(Table table); + + /** + * Create a new DSL SQL standard MERGE statement. + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
dialectsupport typedocumentation
CUBRIDSQL:2008 standard and some enhancementshttp://www.cubrid.org/manual/90/en/MERGE
DB2SQL:2008 standard and major enhancementshttp://publib.boulder.ibm.com/infocenter/db2luw/v9/index.jsp?topic=/com. + * ibm.db2.udb.admin.doc/doc/r0010873.htm
HSQLDBSQL:2008 standardhttp://hsqldb.org/doc/2.0/guide/dataaccess-chapt.html#N129BA
OracleSQL:2008 standard and minor enhancementshttp://download.oracle.com/docs/cd/B28359_01/server.111/b28286/ + * statements_9016.htm
SQL ServerSimilar to SQL:2008 standard with some major enhancementshttp://msdn.microsoft.com/de-de/library/bb510625.aspx
SybaseSimilar to SQL:2008 standard with some major enhancementshttp://dcx.sybase.com/1100/en/dbreference_en11/merge-statement.html
+ *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.mergeInto(table)
+     *       .using(select)
+     *       .on(condition)
+     *       .whenMatchedThenUpdate()
+     *       .set(field1, value1)
+     *       .set(field2, value2)
+     *       .whenNotMatchedThenInsert(field1, field2)
+     *       .values(value1, value2)
+     *       .execute();
+     *
+ *

+ * Note: Using this method, you can also create an H2-specific MERGE + * statement without field specification. See also + * {@link #mergeInto(Table, Field...)} + */ + @Support({ CUBRID, DB2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeUsingStep mergeInto(Table table); + + // [jooq-tools] START [merge] + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep1 mergeInto(Table table, Field field1); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep2 mergeInto(Table table, Field field1, Field field2); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep3 mergeInto(Table table, Field field1, Field field2, Field field3); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep4 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep5 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep6 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep7 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep8 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep9 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep10 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep11 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep12 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep13 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep14 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep15 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep16 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep17 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep18 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep19 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep20 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep21 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21); + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Generated("This method was generated using jOOQ-tools") + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStep22 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21, Field field22); + +// [jooq-tools] END [merge] + + /** + * Create a new DSL merge statement (H2-specific syntax) + *

+ * This statement is available from DSL syntax only. It is known to be + * supported in some way by any of these dialects: + * + * + * + * + * + * + * + * + * + * + * + *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a + * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
+ */ + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStepN mergeInto(Table table, Field... fields); + + /** + * Create a new DSL merge statement (H2-specific syntax) + * + * @see #mergeInto(Table, Field...) + */ + @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + MergeKeyStepN mergeInto(Table table, Collection> fields); + + /** + * Create a new {@link DeleteQuery} + * + * @param table The table to delete data from + * @return The new {@link DeleteQuery} + */ + @Support + DeleteQuery deleteQuery(Table table); + + /** + * Create a new DSL delete statement. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.delete(table)
+     *       .where(field1.greaterThan(100))
+     *       .execute();
+     *
+ */ + @Support + DeleteWhereStep delete(Table table); + + // ------------------------------------------------------------------------- + // XXX Batch query execution + // ------------------------------------------------------------------------- + + /** + * Execute a set of queries in batch mode (without bind values). + *

+ * This essentially runs the following logic: 

+     * Statement s = connection.createStatement();
+     *
+     * for (Query query : queries) {
+     *     s.addBatch(query.getSQL(true));
+     * }
+     *
+     * s.execute();
+     *
+ * + * @see Statement#executeBatch() + */ + @Support + Batch batch(Query... queries); + + /** + * Execute a set of queries in batch mode (without bind values). + *

+ * This essentially runs the following logic: 

+     * Statement s = connection.createStatement();
+     *
+     * for (Query query : queries) {
+     *     s.addBatch(query.getSQL(true));
+     * }
+     *
+     * s.execute();
+     *
+ * + * @see Statement#executeBatch() + */ + @Support + Batch batch(Collection queries); + + /** + * Execute a set of queries in batch mode (with bind values). + *

+ * When running 

+     * create.batch(query)
+     *       .bind(valueA1, valueA2)
+     *       .bind(valueB1, valueB2)
+     *       .execute();
+     *
+ *

+ * This essentially runs the following logic: 

+     * Statement s = connection.prepareStatement(query.getSQL(false));
+     *
+     * for (Object[] bindValues : allBindValues) {
+     *     for (Object bindValue : bindValues) {
+     *         s.setXXX(bindValue);
+     *     }
+     *
+     *     s.addBatch();
+     * }
+     *
+     * s.execute();
+     *
+ *

+ * Note: bind values will be inlined to a static batch query as in + * {@link #batch(Query...)}, if you choose to execute queries with + * {@link Settings#getStatementType()} == {@link StatementType#STATIC_STATEMENT} + * + * @see Statement#executeBatch() + */ + @Support + BatchBindStep batch(Query query); + + /** + * Execute a set of INSERT and UPDATE queries in + * batch mode (with bind values). + *

+ * This batch operation can be executed in two modes: + *

+ *

With + * {@link Settings#getStatementType()} == {@link StatementType#PREPARED_STATEMENT} + * (the default)
+ *

+ * In this mode, record order is preserved as much as possible, as long as + * two subsequent records generate the same SQL (with bind variables). The + * number of executed batch operations corresponds to + * [number of distinct rendered SQL statements]. In the worst + * case, this corresponds to the number of total records. + *

+ * The record type order is preserved in the way they are passed to this + * method. This is an example of how statements will be ordered: 

+     * // Let's assume, odd numbers result in INSERTs and even numbers in UPDATES
+     * // Let's also assume a[n] are all of the same type, just as b[n], c[n]...
+     * int[] result = create.batchStore(a1, a2, a3, b1, a4, c1, b3, a5)
+     *                      .execute();
+     *
The above results in result.length == 8 and + * the following 4 separate batch statements: + *
    + *
  1. INSERT a1, a3, a5
    2. + *
  2. UPDATE a2, a4
    3. + *
  3. INSERT b1, b3
    4. + *
  4. INSERT c1
    5. + *
+ *

+ *

With + * {@link Settings#getStatementType()} == {@link StatementType#STATIC_STATEMENT} + *
+ *

+ * This mode may be better for large and complex batch store operations, as + * the order of records is preserved entirely, and jOOQ can guarantee that + * only a single batch statement is serialised to the database. + * + * @see Statement#executeBatch() + */ + @Support + Batch batchStore(UpdatableRecord... records); + + /** + * Execute a set of INSERT and UPDATE queries in + * batch mode (with bind values). + * + * @see #batchStore(UpdatableRecord...) + * @see Statement#executeBatch() + */ + @Support + Batch batchStore(Collection> records); + + /** + * Execute a set of INSERT queries in batch mode (with bind + * values). + * + * @see #batchStore(UpdatableRecord...) + * @see Statement#executeBatch() + */ + @Support + Batch batchInsert(UpdatableRecord... records); + + /** + * Execute a set of INSERT queries in batch mode (with bind + * values). + * + * @see #batchStore(UpdatableRecord...) + * @see Statement#executeBatch() + */ + @Support + Batch batchInsert(Collection> records); + + /** + * Execute a set of UPDATE queries in batch mode (with bind + * values). + * + * @see #batchStore(UpdatableRecord...) + * @see Statement#executeBatch() + */ + @Support + Batch batchUpdate(UpdatableRecord... records); + + /** + * Execute a set of UPDATE queries in batch mode (with bind + * values). + * + * @see #batchStore(UpdatableRecord...) + * @see Statement#executeBatch() + */ + @Support + Batch batchUpdate(Collection> records); + + /** + * Execute a set of DELETE queries in batch mode (with bind + * values). + *

+ * This batch operation can be executed in two modes: + *

+ *

With + * {@link Settings#getStatementType()} == {@link StatementType#PREPARED_STATEMENT} + * (the default)
+ *

+ * In this mode, record order is preserved as much as possible, as long as + * two subsequent records generate the same SQL (with bind variables). The + * number of executed batch operations corresponds to + * [number of distinct rendered SQL statements]. In the worst + * case, this corresponds to the number of total records. + *

+ * The record type order is preserved in the way they are passed to this + * method. This is an example of how statements will be ordered: 

+     * // Let's assume a[n] are all of the same type, just as b[n], c[n]...
+     * int[] result = create.batchStore(a1, a2, a3, b1, a4, c1, c2, a5)
+     *                      .execute();
+     *
The above results in result.length == 8 and + * the following 5 separate batch statements: + *
    + *
  1. DELETE a1, a2, a3
    2. + *
  2. DELETE b1
    3. + *
  3. DELETE a4
    4. + *
  4. DELETE c1, c2
    5. + *
  5. DELETE a5
    6. + *
+ *

+ *

With + * {@link Settings#getStatementType()} == {@link StatementType#STATIC_STATEMENT} + *
+ *

+ * This mode may be better for large and complex batch delete operations, as + * the order of records is preserved entirely, and jOOQ can guarantee that + * only a single batch statement is serialised to the database. + * + * @see Statement#executeBatch() + */ + @Support + Batch batchDelete(UpdatableRecord... records); + + /** + * Execute a set of DELETE in batch mode (with bind values). + * + * @see #batchDelete(UpdatableRecord...) + * @see Statement#executeBatch() + */ + @Support + Batch batchDelete(Collection> records); + + // ------------------------------------------------------------------------- + // XXX DDL Statements + // ------------------------------------------------------------------------- + + /** + * Create a new DSL truncate statement. + *

+ * Example: 

+     * Executor create = Factory.using();
+     *
+     * create.truncate(table)
+     *       .execute();
+     *
+ *

+ * Most dialects implement the TRUNCATE statement. If it is not + * supported, it is simulated using an equivalent DELETE + * statement. This is particularly true for these dialects: + *

    + *
  • {@link SQLDialect#FIREBIRD}
    • + *
  • {@link SQLDialect#INGRES}
    • + *
  • {@link SQLDialect#SQLITE}
    • + *
+ *

+ * Note, this statement is only supported in DSL mode. Immediate execution + * is omitted for future extensibility of this command. + */ + @Support + Truncate truncate(Table table); + + // ------------------------------------------------------------------------- + // XXX Other queries for identites and sequences + // ------------------------------------------------------------------------- + + /** + * Retrieve the last inserted ID. + *

+ * Note, there are some restrictions to the following dialects: + *

    + *
  • {@link SQLDialect#DB2} doesn't support this
    • + *
  • {@link SQLDialect#ORACLE} doesn't support this
    • + *
  • {@link SQLDialect#POSTGRES} doesn't support this
    • + *
  • {@link SQLDialect#SQLITE} supports this, but its support is poorly + * documented.
    • + *
+ * + * @return The last inserted ID. This may be null in some + * dialects, if no such number is available. + * @throws DataAccessException if something went wrong executing the query + */ + @Support({ ASE, CUBRID, DERBY, H2, HSQLDB, INGRES, MYSQL, SQLITE, SQLSERVER, SYBASE }) + BigInteger lastID() throws DataAccessException; + + /** + * Convenience method to fetch the NEXTVAL for a sequence directly from this + * {@link Executor}'s underlying JDBC {@link Connection} + * + * @throws DataAccessException if something went wrong executing the query + */ + @Support({ CUBRID, DB2, DERBY, FIREBIRD, H2, HSQLDB, INGRES, ORACLE, POSTGRES, SYBASE }) + T nextval(Sequence sequence) throws DataAccessException; + + /** + * Convenience method to fetch the CURRVAL for a sequence directly from this + * {@link Executor}'s underlying JDBC {@link Connection} + * + * @throws DataAccessException if something went wrong executing the query + */ + @Support({ CUBRID, DB2, FIREBIRD, H2, INGRES, ORACLE, POSTGRES, SYBASE }) + T currval(Sequence sequence) throws DataAccessException; + + /** + * Use a schema as the default schema of the underlying connection. + *

+ * This has two effects. + *

    + *
  1. The USE [schema] statement is executed on those RDBMS + * that support this
    2. + *
  2. The supplied {@link Schema} is used as the default schema resulting + * in omitting that schema in rendered SQL.
    3. + *
+ *

+ * The USE [schema] statement translates to the various + * dialects as follows: + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
DialectCommand
DB2SET SCHEMA [schema]
Derby:SET SCHEMA [schema]
H2:SET SCHEMA [schema]
HSQLDB:SET SCHEMA [schema]
MySQL:USE [schema]
Oracle:ALTER SESSION SET CURRENT_SCHEMA = [schema]
Postgres:SET SEARCH_PATH = [schema]
Sybase:USE [schema]
+ * + * @throws DataAccessException if something went wrong executing the query + */ + @Support({ DB2, DERBY, H2, HSQLDB, MYSQL, SYBASE, ORACLE, POSTGRES, SYBASE }) + int use(Schema schema) throws DataAccessException; + + /** + * Use a schema as the default schema of the underlying connection. + * + * @see #use(Schema) + * @throws DataAccessException if something went wrong executing the query + */ + @Support({ DB2, DERBY, H2, HSQLDB, MYSQL, SYBASE, ORACLE, POSTGRES, SYBASE }) + int use(String schema) throws DataAccessException; + + // ------------------------------------------------------------------------- + // XXX Global Record factory + // ------------------------------------------------------------------------- + + /** + * Create a new {@link UDTRecord}. + *

+ * The resulting record is attached to this {@link Configuration} by + * default. Use {@link Settings#isAttachRecords()} to override this + * behaviour. + * + * @param The generic record type + * @param type The UDT describing records of type <R> + * @return The new record + */ + > R newRecord(UDT type); + + /** + * Create a new {@link Record} that can be inserted into the corresponding + * table. + *

+ * The resulting record is attached to this {@link Configuration} by + * default. Use {@link Settings#isAttachRecords()} to override this + * behaviour. + * + * @param The generic record type + * @param table The table holding records of type <R> + * @return The new record + */ + R newRecord(Table table); + + /** + * Create a new pre-filled {@link Record} that can be inserted into the + * corresponding table. + *

+ * This performs roughly the inverse operation of {@link Record#into(Class)} + *

+ * The resulting record will have its internal "changed" flags set to true + * for all values. This means that {@link UpdatableRecord#store()} will + * perform an INSERT statement. If you wish to store the record + * using an UPDATE statement, use + * {@link #executeUpdate(UpdatableRecord)} instead. + *

+ * The resulting record is attached to this {@link Configuration} by + * default. Use {@link Settings#isAttachRecords()} to override this + * behaviour. + * + * @param The generic record type + * @param table The table holding records of type <R> + * @param source The source to be used to fill the new record + * @return The new record + * @throws MappingException wrapping any reflection or data type conversion + * exception that might have occurred while mapping records + * @see Record#from(Object) + * @see Record#into(Class) + */ + R newRecord(Table table, Object source); + + /** + * Create a new empty {@link Result}. + *

+ * The result is attached to this {@link Configuration} by default. This + * result can be used as a container for records. + * + * @param The generic record type + * @param table The table holding records of type <R> + * @return The new result + */ + Result newResult(Table table); + + // ------------------------------------------------------------------------- + // XXX Executing queries + // ------------------------------------------------------------------------- + + /** + * Execute a {@link ResultQuery} in the context of this executor and return + * results. + * + * @param query The query to execute + * @return The result + * @throws DataAccessException if something went wrong executing the query + * @see ResultQuery#fetch() + */ + Result fetch(ResultQuery query) throws DataAccessException; + + /** + * Execute a {@link ResultQuery} in the context of this executor and return + * a cursor. + * + * @param query The query to execute + * @return The cursor + * @throws DataAccessException if something went wrong executing the query + * @see ResultQuery#fetchLazy() + */ + Cursor fetchLazy(ResultQuery query) throws DataAccessException; + + /** + * Execute a {@link ResultQuery} in the context of this executor and return + * a cursor. + * + * @param query The query to execute + * @return The results + * @throws DataAccessException if something went wrong executing the query + * @see ResultQuery#fetchMany() + */ + List> fetchMany(ResultQuery query) throws DataAccessException; + + /** + * Execute a {@link ResultQuery} in the context of this executor and return + * a record. + * + * @param query The query to execute + * @return The record + * @throws DataAccessException if something went wrong executing the query + * @throws InvalidResultException if the query returned more than one record + * @see ResultQuery#fetchOne() + */ + R fetchOne(ResultQuery query) throws DataAccessException, InvalidResultException; + + /** + * Execute a {@link Select} query in the context of this executor and return + * a COUNT(*) value. + *

+ * This wraps a pre-existing SELECT query in another one to + * calculate the COUNT(*) value, without modifying the original + * SELECT. An example: 

+     * -- Original query:
+     * SELECT id, title FROM book WHERE title LIKE '%a%'
+     *
+     * -- Wrapped query:
+     * SELECT count(*) FROM (
+     *   SELECT id, title FROM book WHERE title LIKE '%a%'
+     * )
+     *
This is particularly useful for those databases that do not + * support the COUNT(*) OVER() window function to calculate + * total results in paged queries. + * + * @param query The wrapped query + * @return The COUNT(*) result + * @throws DataAccessException if something went wrong executing the query + */ + int fetchCount(Select query) throws DataAccessException; + + /** + * Execute a {@link Query} in the context of this executor. + * + * @param query The query to execute + * @return The number of affected rows + * @throws DataAccessException if something went wrong executing the query + * @see Query#execute() + */ + int execute(Query query) throws DataAccessException; + + // ------------------------------------------------------------------------- + // XXX Fast querying + // ------------------------------------------------------------------------- + + /** + * Execute and return all records for + * 
SELECT * FROM [table]
 + *

+ * The result and its contained records are attached to this + * {@link Configuration} by default. Use {@link Settings#isAttachRecords()} + * to override this behaviour. + * + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Result fetch(Table table) throws DataAccessException; + + /** + * Execute and return all records for + * 

SELECT * FROM [table] WHERE [condition]
+ *

+ * The result and its contained records are attached to this + * {@link Configuration} by default. Use {@link Settings#isAttachRecords()} + * to override this behaviour. + * + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Result fetch(Table table, Condition condition) throws DataAccessException; + + /** + * Execute and return zero or one record for + * 

SELECT * FROM [table]
+ *

+ * The resulting record is attached to this {@link Configuration} by + * default. Use {@link Settings#isAttachRecords()} to override this + * behaviour. + * + * @return The record or null if no record was returned + * @throws DataAccessException if something went wrong executing the query + * @throws InvalidResultException if the query returned more than one record + */ + @Support + R fetchOne(Table table) throws DataAccessException, InvalidResultException; + + /** + * Execute and return zero or one record for + * 

SELECT * FROM [table] WHERE [condition]
+ *

+ * The resulting record is attached to this {@link Configuration} by + * default. Use {@link Settings#isAttachRecords()} to override this + * behaviour. + * + * @return The record or null if no record was returned + * @throws DataAccessException if something went wrong executing the query + * @throws InvalidResultException if the query returned more than one record + */ + @Support + R fetchOne(Table table, Condition condition) throws DataAccessException, + InvalidResultException; + + /** + * Execute and return zero or one record for + * 

SELECT * FROM [table] LIMIT 1
+ *

+ * The resulting record is attached to this {@link Configuration} by + * default. Use {@link Settings#isAttachRecords()} to override this + * behaviour. + * + * @return The record or null if no record was returned + * @throws DataAccessException if something went wrong executing the query + */ + @Support + R fetchAny(Table table) throws DataAccessException; + + /** + * Execute and return all records lazily for + * 

SELECT * FROM [table]
+ *

+ * The result and its contained records are attached to this + * {@link Configuration} by default. Use {@link Settings#isAttachRecords()} + * to override this behaviour. + * + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Cursor fetchLazy(Table table) throws DataAccessException; + + /** + * Execute and return all records lazily for + * 

SELECT * FROM [table] WHERE [condition]
+ *

+ * The result and its contained records are attached to this + * {@link Configuration} by default. Use {@link Settings#isAttachRecords()} + * to override this behaviour. + * + * @throws DataAccessException if something went wrong executing the query + */ + @Support + Cursor fetchLazy(Table table, Condition condition) throws DataAccessException; + + /** + * Insert one record + *

+ * This executes something like the following statement: + * 

INSERT INTO [table] ... VALUES [record]
+ *

+ * Unlike {@link UpdatableRecord#store()}, this does not change any of the + * argument record's internal "changed" flags, such that a + * subsequent call to {@link UpdatableRecord#store()} might lead to another + * INSERT statement being executed. + * + * @return The number of inserted records + * @throws DataAccessException if something went wrong executing the query + */ + @Support + > int executeInsert(R record) throws DataAccessException; + + /** + * Update a table + * 

UPDATE [table] SET [modified values in record] WHERE [record is supplied record]
+ * + * @return The number of updated records + * @throws DataAccessException if something went wrong executing the query + */ + @Support + > int executeUpdate(R record) throws DataAccessException; + + /** + * Update a table + * 
UPDATE [table] SET [modified values in record] WHERE [condition]
 + * + * @return The number of updated records + * @throws DataAccessException if something went wrong executing the query + */ + @Support + , T> int executeUpdate(R record, Condition condition) throws DataAccessException; + + /** + * Delete a record from a table + * 
DELETE FROM [table] WHERE [record is supplied record]
 + * + * @return The number of deleted records + * @throws DataAccessException if something went wrong executing the query + */ + @Support + > int executeDelete(R record) throws DataAccessException; + + /** + * Delete a record from a table + * 
DELETE FROM [table] WHERE [condition]
 + * + * @return The number of deleted records + * @throws DataAccessException if something went wrong executing the query + */ + @Support + , T> int executeDelete(R record, Condition condition) throws DataAccessException; +} diff --git a/jOOQ/src/main/java/org/jooq/impl/Executor.java b/jOOQ/src/main/java/org/jooq/impl/Executor.java index 94a7e4b0be..1e0066497f 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Executor.java +++ b/jOOQ/src/main/java/org/jooq/impl/Executor.java @@ -65,7 +65,6 @@ import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; -import java.sql.Statement; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; @@ -83,7 +82,7 @@ import org.jooq.BindContext; import org.jooq.Condition; import org.jooq.Configuration; import org.jooq.ConnectionProvider; -import org.jooq.Converter; +import org.jooq.ContextDSL; import org.jooq.Cursor; import org.jooq.DataType; import org.jooq.DeleteQuery; @@ -168,31 +167,9 @@ import org.jooq.Record6; import org.jooq.Record7; import org.jooq.Record8; import org.jooq.Record9; -import org.jooq.RecordHandler; import org.jooq.RenderContext; import org.jooq.Result; import org.jooq.ResultQuery; -import org.jooq.Row10; -import org.jooq.Row11; -import org.jooq.Row12; -import org.jooq.Row13; -import org.jooq.Row14; -import org.jooq.Row15; -import org.jooq.Row16; -import org.jooq.Row17; -import org.jooq.Row18; -import org.jooq.Row19; -import org.jooq.Row2; -import org.jooq.Row20; -import org.jooq.Row21; -import org.jooq.Row22; -import org.jooq.Row3; -import org.jooq.Row4; -import org.jooq.Row5; -import org.jooq.Row6; -import org.jooq.Row7; -import org.jooq.Row8; -import org.jooq.Row9; import org.jooq.SQLDialect; import org.jooq.Schema; import org.jooq.Select; @@ -211,49 +188,17 @@ import org.jooq.UpdatableRecord; import org.jooq.UpdateQuery; import org.jooq.UpdateSetFirstStep; import org.jooq.conf.Settings; -import org.jooq.conf.StatementType; import org.jooq.exception.DataAccessException; import org.jooq.exception.InvalidResultException; -import org.jooq.exception.MappingException; import org.jooq.exception.SQLDialectNotSupportedException; import org.jooq.impl.BatchCRUD.Action; import org.jooq.tools.csv.CSVReader; /** - * A factory providing "attached" implementations to the org.jooq - * interfaces. - *

- * Apart from the {@link Factory}, this executor is the main entry point for - * client code, to access jOOQ classes and functionality that are related to - * {@link Query} execution. Unlike objects created through the - * Factory, objects created from an Executor will be - * "attached" to the Executor's {@link #configuration()}, such that - * they can be executed immediately in a fluent style. An example is given here: - *

- * 

- * Executor create = Factory.using(connection, dialect);
- *
- * // Immediately fetch results after constructing a query
- * create.selectFrom(MY_TABLE).where(MY_TABLE.ID.eq(1)).fetch();
- *
- * // The above is equivalent to this "non-fluent" style
- * create.fetch(Factory.selectFrom(MY_TABLE).where(MY_TABLE.ID.eq(1)));
- *
- *

- * The Executor provides convenient constructors to create a - * {@link Configuration}, which will be shared among all Query - * objects thus created. Optionally, you can pass a reusable - * Configuration to the {@link Factory#using(Configuration)} - * constructor. Please consider thread-safety concerns documented in - * {@link Configuration}, should you want to reuse the same - * Configuration instance in various threads and / or transactions. - * - * @see Factory - * @see Configuration * @author Lukas Eder */ @SuppressWarnings({ "rawtypes", "unchecked" }) -public class Executor implements Serializable { +public class Executor implements ContextDSL, Serializable { /** * Generated UID @@ -265,143 +210,38 @@ public class Executor implements Serializable { // XXX Constructors // ------------------------------------------------------------------------- - /** - * Create an executor with a dialect configured. - *

- * Without a connection or data source, this executor cannot execute - * queries. Use it to render SQL only. - * - * @param dialect The dialect to use with objects created from this executor - */ Executor(SQLDialect dialect) { this(dialect, null); } - /** - * Create an executor with a dialect and settings configured. - *

- * Without a connection or data source, this executor cannot execute - * queries. Use it to render SQL only. - * - * @param dialect The dialect to use with objects created from this executor - * @param settings The runtime settings to apply to objects created from - * this executor - */ Executor(SQLDialect dialect, Settings settings) { this(new DefaultConfiguration(new NoConnectionProvider(), dialect, settings, null)); } - /** - * Create an executor with a connection and a dialect configured. - *

- * If you provide a JDBC connection to a jOOQ Executor, jOOQ will use that - * connection directly for creating statements. - *

- * This is a convenience constructor for - * {@link #Executor(ConnectionProvider, SQLDialect, Settings)} using a - * {@link DefaultConnectionProvider} - * - * @param connection The connection to use with objects created from this - * executor - * @param dialect The dialect to use with objects created from this executor - * @see DefaultConnectionProvider - */ Executor(Connection connection, SQLDialect dialect) { this(connection, dialect, null); } - /** - * Create an executor with a connection, a dialect and settings configured. - *

- * If you provide a JDBC connection to a jOOQ Executor, jOOQ will use that - * connection directly for creating statements. - *

- * This is a convenience constructor for - * {@link #Executor(ConnectionProvider, SQLDialect, Settings)} using a - * {@link DefaultConnectionProvider} - * - * @param connection The connection to use with objects created from this - * executor - * @param dialect The dialect to use with objects created from this executor - * @param settings The runtime settings to apply to objects created from - * this executor - * @see DefaultConnectionProvider - */ Executor(Connection connection, SQLDialect dialect, Settings settings) { this(new DefaultConfiguration(new DefaultConnectionProvider(connection), dialect, settings, null)); } - /** - * Create an executor with a data source and a dialect configured. - *

- * If you provide a JDBC data source to a jOOQ Executor, jOOQ will use that - * data source for initialising connections, and creating statements. - *

- * This is a convenience constructor for - * {@link #Executor(ConnectionProvider, SQLDialect)} using a - * {@link DataSourceConnectionProvider} - * - * @param datasource The data source to use with objects created from this - * executor - * @param dialect The dialect to use with objects created from this executor - * @see DataSourceConnectionProvider - */ Executor(DataSource datasource, SQLDialect dialect) { this(datasource, dialect, null); } - /** - * Create an executor with a data source, a dialect and settings configured. - *

- * If you provide a JDBC data source to a jOOQ Executor, jOOQ will use that - * data source for initialising connections, and creating statements. - *

- * This is a convenience constructor for - * {@link #Executor(ConnectionProvider, SQLDialect, Settings)} using a - * {@link DataSourceConnectionProvider} - * - * @param datasource The data source to use with objects created from this - * executor - * @param dialect The dialect to use with objects created from this executor - * @param settings The runtime settings to apply to objects created from - * this executor - * @see DataSourceConnectionProvider - */ Executor(DataSource datasource, SQLDialect dialect, Settings settings) { this(new DefaultConfiguration(new DataSourceConnectionProvider(datasource), dialect, settings, null)); } - /** - * Create an executor with a custom connection provider and a dialect - * configured. - * - * @param connectionProvider The connection provider providing jOOQ with - * JDBC connections - * @param dialect The dialect to use with objects created from this executor - */ Executor(ConnectionProvider connectionProvider, SQLDialect dialect) { this(connectionProvider, dialect, null); } - /** - * Create an executor with a custom connection provider, a dialect and settings - * configured. - * - * @param connectionProvider The connection provider providing jOOQ with - * JDBC connections - * @param dialect The dialect to use with objects created from this executor - * @param settings The runtime settings to apply to objects created from - * this executor - */ Executor(ConnectionProvider connectionProvider, SQLDialect dialect, Settings settings) { this(new DefaultConfiguration(connectionProvider, dialect, settings, null)); } - /** - * Create an executor from a custom configuration. - * - * @param configuration The configuration - */ Executor(Configuration configuration) { // The Configuration can be null when unattached Query objects are @@ -417,34 +257,17 @@ public class Executor implements Serializable { // XXX Configuration API // ------------------------------------------------------------------------- + @Override public final Configuration configuration() { return configuration; } - /** - * Map a schema to another one. - *

- * This will map a schema onto another one, depending on configured schema - * mapping in this Executor. If no applicable schema mapping - * can be found, the schema itself is returned. - * - * @param schema A schema - * @return The mapped schema - */ + @Override public final Schema map(Schema schema) { return Utils.getMappedSchema(configuration, schema); } - /** - * Map a table to another one. - *

- * This will map a table onto another one, depending on configured table - * mapping in this Executor. If no applicable table mapping - * can be found, the table itself is returned. - * - * @param table A table - * @return The mapped table - */ + @Override public final Table map(Table table) { return Utils.getMappedTable(configuration, table); } @@ -453,12 +276,7 @@ public class Executor implements Serializable { // XXX Convenience methods accessing the underlying Connection // ------------------------------------------------------------------------- - /** - * Access the database meta data. - *

- * This method returns a wrapper type that gives access to your JDBC - * connection's database meta data. - */ + @Override public final Meta meta() { return new MetaImpl(configuration); } @@ -467,74 +285,27 @@ public class Executor implements Serializable { // XXX RenderContext and BindContext accessors // ------------------------------------------------------------------------- - /** - * Get a new {@link RenderContext} for the context of this executor. - *

- * This will return an initialised render context as such: - *

    - *
  • - * {@link RenderContext#castMode()} == {@link org.jooq.RenderContext.CastMode#DEFAULT DEFAULT} - *
    • - *
  • {@link RenderContext#declareFields()} == false
    • - *
  • {@link RenderContext#declareTables()} == false
    • - *
  • {@link RenderContext#format()} == false
    • - *
  • {@link RenderContext#inline()} == false
    • - *
  • {@link RenderContext#namedParams()} == false
    • - *
  • {@link RenderContext#qualify()} == true
    • - *
  • {@link RenderContext#subquery()} == false
    • - *
- */ + @Override public final RenderContext renderContext() { return new DefaultRenderContext(configuration); } - /** - * Render a QueryPart in the context of this executor. - *

- * This is the same as calling renderContext().render(part) - * - * @param part The {@link QueryPart} to be rendered - * @return The rendered SQL - */ + @Override public final String render(QueryPart part) { return renderContext().render(part); } - /** - * Render a QueryPart in the context of this executor, rendering bind - * variables as named parameters. - *

- * This is the same as calling - * renderContext().namedParams(true).render(part) - * - * @param part The {@link QueryPart} to be rendered - * @return The rendered SQL - */ + @Override public final String renderNamedParams(QueryPart part) { return renderContext().namedParams(true).render(part); } - /** - * Render a QueryPart in the context of this executor, inlining all bind - * variables. - *

- * This is the same as calling - * renderContext().inline(true).render(part) - * - * @param part The {@link QueryPart} to be rendered - * @return The rendered SQL - */ + @Override public final String renderInlined(QueryPart part) { return renderContext().inline(true).render(part); } - /** - * Retrieve the bind values that will be bound by a given - * QueryPart. - *

- * The returned List is immutable. To modify bind values, use - * {@link #extractParams(QueryPart)} instead. - */ + @Override public final List extractBindValues(QueryPart part) { List result = new ArrayList(); @@ -545,64 +316,24 @@ public class Executor implements Serializable { return Collections.unmodifiableList(result); } - /** - * Get a Map of named parameters. - *

- * The Map itself is immutable, but the {@link Param} elements - * allow for modifying bind values on an existing {@link Query} (or any - * other {@link QueryPart}). - *

- * Bind values created with {@link Factory#val(Object)} will have their bind - * index as name. - * - * @see Param - * @see Factory#param(String, Object) - */ + @Override public final Map> extractParams(QueryPart part) { ParamCollector collector = new ParamCollector(configuration); collector.bind(part); return Collections.unmodifiableMap(collector.result); } - /** - * Get a named parameter from a {@link QueryPart}, provided its name. - *

- * Bind values created with {@link Factory#val(Object)} will have their bind - * index as name. - * - * @see Param - * @see Factory#param(String, Object) - */ + @Override public final Param extractParam(QueryPart part, String name) { return extractParams(part).get(name); } - /** - * Get a new {@link BindContext} for the context of this executor. - *

- * This will return an initialised bind context as such: - *

    - *
  • {@link RenderContext#declareFields()} == false
    • - *
  • {@link RenderContext#declareTables()} == false
    • - *
- *

- * RenderContext for JOOQ INTERNAL USE only. Avoid referencing it directly - */ + @Override public final BindContext bindContext(PreparedStatement stmt) { return new DefaultBindContext(configuration, stmt); } - /** - * Get a new {@link BindContext} for the context of this executor. - *

- * This will return an initialised bind context as such: - *

    - *
  • {@link RenderContext#declareFields()} == false
    • - *
  • {@link RenderContext#declareTables()} == false
    • - *
- *

- * RenderContext for JOOQ INTERNAL USE only. Avoid referencing it directly - */ + @Override public final int bind(QueryPart part, PreparedStatement stmt) { return bindContext(stmt).bind(part).peekIndex(); } @@ -611,16 +342,12 @@ public class Executor implements Serializable { // XXX Attachable and Serializable API // ------------------------------------------------------------------------- - /** - * Attach this Executor to some attachables. - */ + @Override public final void attach(Attachable... attachables) { attach(Arrays.asList(attachables)); } - /** - * Attach this Executor to some attachables. - */ + @Override public final void attach(Collection attachables) { for (Attachable attachable : attachables) { attachable.attach(configuration); @@ -631,674 +358,133 @@ public class Executor implements Serializable { // XXX Access to the loader API // ------------------------------------------------------------------------- - /** - * Create a new Loader object to load data from a CSV or XML - * source. - */ + @Override @Support public final > LoaderOptionsStep loadInto(Table table) { return new LoaderImpl(configuration, table); } - /** - * Create a new query holding plain SQL. There must not be any binding - * variables contained in the SQL. - *

- * Example: - *

- * 

-     * String sql = "SET SCHEMA 'abc'";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @return A query wrapping the plain SQL - */ + @Override @Support public final Query query(String sql) { return query(sql, new Object[0]); } - /** - * Create a new query holding plain SQL. There must be as many bind - * variables contained in the SQL, as passed in the bindings parameter. - *

- * Example: - *

- * 

-     * String sql = "SET SCHEMA 'abc'";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @param bindings The bindings - * @return A query wrapping the plain SQL - */ + @Override @Support public final Query query(String sql, Object... bindings) { return new SQLQuery(configuration, sql, bindings); } - /** - * Create a new query holding plain SQL. - *

- * Unlike {@link #query(String, Object...)}, the SQL passed to this method - * should not contain any bind variables. Instead, you can pass - * {@link QueryPart} objects to the method which will be rendered at indexed - * locations of your SQL string as such: 

-     * // The following query
-     * query("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
-     *
-     * // Will render this SQL on an Oracle database with RenderNameStyle.QUOTED:
-     * select ?, 'test' from "DUAL"
-     *
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! One way to escape - * literals is to use {@link Factory#name(String...)} and similar methods - * - * @param sql The SQL clause, containing {numbered placeholders} where query - * parts can be injected - * @param parts The {@link QueryPart} objects that are rendered at the - * {numbered placeholder} locations - * @return A query wrapping the plain SQL - */ + @Override @Support public final Query query(String sql, QueryPart... parts) { return new SQLQuery(configuration, sql, parts); } - /** - * Execute a new query holding plain SQL. - *

- * Example (Postgres): - *

- * 

-     * String sql = "FETCH ALL IN \"\"";
Example - * (SQLite): - *

- * 

-     * String sql = "pragma table_info('my_table')";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @return The results from the executed query. This is never - * null, even if the database returns no - * {@link ResultSet} - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Result fetch(String sql) throws DataAccessException { return resultQuery(sql).fetch(); } - /** - * Execute a new query holding plain SQL. - *

- * There must be as many bind variables contained in the SQL, as passed in - * the bindings parameter - *

- * Example (Postgres): - *

- * 

-     * String sql = "FETCH ALL IN \"\"";
Example - * (SQLite): - *

- * 

-     * String sql = "pragma table_info('my_table')";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @param bindings The bindings - * @return The results from the executed query. This is never - * null, even if the database returns no - * {@link ResultSet} - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Result fetch(String sql, Object... bindings) throws DataAccessException { return resultQuery(sql, bindings).fetch(); } - /** - * Execute a new query holding plain SQL. - *

- * Unlike {@link #fetch(String, Object...)}, the SQL passed to this method - * should not contain any bind variables. Instead, you can pass - * {@link QueryPart} objects to the method which will be rendered at indexed - * locations of your SQL string as such: 

-     * // The following query
-     * fetch("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
-     *
-     * // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
-     * select ?, 'test' from "DUAL"
-     *
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! One way to escape - * literals is to use {@link Factory#name(String...)} and similar methods - * - * @param sql The SQL clause, containing {numbered placeholders} where query - * parts can be injected - * @param parts The {@link QueryPart} objects that are rendered at the - * {numbered placeholder} locations - * @return The results from the executed query - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Result fetch(String sql, QueryPart... parts) throws DataAccessException { return resultQuery(sql, parts).fetch(); } - /** - * Execute a new query holding plain SQL and "lazily" return the generated - * result. - *

- * The returned {@link Cursor} holds a reference to the executed - * {@link PreparedStatement} and the associated {@link ResultSet}. Data can - * be fetched (or iterated over) lazily, fetching records from the - * {@link ResultSet} one by one. - *

- * Example (Postgres): - *

- * 

-     * String sql = "FETCH ALL IN \"\"";
Example - * (SQLite): - *

- * 

-     * String sql = "pragma table_info('my_table')";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @return The results from the executed query. This is never - * null, even if the database returns no - * {@link ResultSet} - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Cursor fetchLazy(String sql) throws DataAccessException { return resultQuery(sql).fetchLazy(); } - /** - * Execute a new query holding plain SQL and "lazily" return the generated - * result. - *

- * There must be as many bind variables contained in the SQL, as passed in - * the bindings parameter - *

- * The returned {@link Cursor} holds a reference to the executed - * {@link PreparedStatement} and the associated {@link ResultSet}. Data can - * be fetched (or iterated over) lazily, fetching records from the - * {@link ResultSet} one by one. - *

- * Example (Postgres): - *

- * 

-     * String sql = "FETCH ALL IN \"\"";
Example - * (SQLite): - *

- * 

-     * String sql = "pragma table_info('my_table')";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @param bindings The bindings - * @return The results from the executed query. This is never - * null, even if the database returns no - * {@link ResultSet} - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Cursor fetchLazy(String sql, Object... bindings) throws DataAccessException { return resultQuery(sql, bindings).fetchLazy(); } - /** - * Execute a new query holding plain SQL and "lazily" return the generated - * result. - *

- * The returned {@link Cursor} holds a reference to the executed - * {@link PreparedStatement} and the associated {@link ResultSet}. Data can - * be fetched (or iterated over) lazily, fetching records from the - * {@link ResultSet} one by one. - *

- * Unlike {@link #fetchLazy(String, Object...)}, the SQL passed to this - * method should not contain any bind variables. Instead, you can pass - * {@link QueryPart} objects to the method which will be rendered at indexed - * locations of your SQL string as such: 

-     * // The following query
-     * fetchLazy("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
-     *
-     * // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
-     * select ?, 'test' from "DUAL"
-     *
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! One way to escape - * literals is to use {@link Factory#name(String...)} and similar methods - * - * @param sql The SQL clause, containing {numbered placeholders} where query - * parts can be injected - * @param parts The {@link QueryPart} objects that are rendered at the - * {numbered placeholder} locations - * @return The results from the executed query - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Cursor fetchLazy(String sql, QueryPart... parts) throws DataAccessException { return resultQuery(sql, parts).fetchLazy(); } - /** - * Execute a new query holding plain SQL, possibly returning several result - * sets. - *

- * Example (Sybase ASE): - *

- * 

-     * String sql = "sp_help 'my_table'";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @return The results from the executed query. This is never - * null, even if the database returns no - * {@link ResultSet} - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final List> fetchMany(String sql) throws DataAccessException { return resultQuery(sql).fetchMany(); } - /** - * Execute a new query holding plain SQL, possibly returning several result - * sets. - *

- * There must be as many bind variables contained in the SQL, as passed in - * the bindings parameter - *

- * Example (Sybase ASE): - *

- * 

-     * String sql = "sp_help 'my_table'";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @param bindings The bindings - * @return The results from the executed query. This is never - * null, even if the database returns no - * {@link ResultSet} - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final List> fetchMany(String sql, Object... bindings) throws DataAccessException { return resultQuery(sql, bindings).fetchMany(); } - /** - * Execute a new query holding plain SQL, possibly returning several result - * sets. - *

- * Unlike {@link #fetchMany(String, Object...)}, the SQL passed to this - * method should not contain any bind variables. Instead, you can pass - * {@link QueryPart} objects to the method which will be rendered at indexed - * locations of your SQL string as such: 

-     * // The following query
-     * fetchMany("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
-     *
-     * // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
-     * select ?, 'test' from "DUAL"
-     *
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! One way to escape - * literals is to use {@link Factory#name(String...)} and similar methods - * - * @param sql The SQL clause, containing {numbered placeholders} where query - * parts can be injected - * @param parts The {@link QueryPart} objects that are rendered at the - * {numbered placeholder} locations - * @return The results from the executed query - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final List> fetchMany(String sql, QueryPart... parts) throws DataAccessException { return resultQuery(sql, parts).fetchMany(); } - /** - * Execute a new query holding plain SQL. - *

- * Example (Postgres): - *

- * 

-     * String sql = "FETCH ALL IN \"\"";
Example - * (SQLite): - *

- * 

-     * String sql = "pragma table_info('my_table')";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @return The results from the executed query. This is never - * null, even if the database returns no - * {@link ResultSet} - * @throws DataAccessException if something went wrong executing the query - * @throws InvalidResultException if the query returned more than one record - */ + @Override @Support public final Record fetchOne(String sql) throws DataAccessException, InvalidResultException { return resultQuery(sql).fetchOne(); } - /** - * Execute a new query holding plain SQL. - *

- * There must be as many bind variables contained in the SQL, as passed in - * the bindings parameter - *

- * Example (Postgres): - *

- * 

-     * String sql = "FETCH ALL IN \"\"";
Example - * (SQLite): - *

- * 

-     * String sql = "pragma table_info('my_table')";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @param bindings The bindings - * @return The results from the executed query. This may be - * null if the database returned no records - * @throws DataAccessException if something went wrong executing the query - * @throws InvalidResultException if the query returned more than one record - */ + @Override @Support public final Record fetchOne(String sql, Object... bindings) throws DataAccessException, InvalidResultException { return resultQuery(sql, bindings).fetchOne(); } - /** - * Execute a new query holding plain SQL. - *

- * Unlike {@link #fetchOne(String, Object...)}, the SQL passed to this - * method should not contain any bind variables. Instead, you can pass - * {@link QueryPart} objects to the method which will be rendered at indexed - * locations of your SQL string as such: 

-     * // The following query
-     * fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
-     *
-     * // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
-     * select ?, 'test' from "DUAL"
-     *
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! One way to escape - * literals is to use {@link Factory#name(String...)} and similar methods - * - * @param sql The SQL clause, containing {numbered placeholders} where query - * parts can be injected - * @param parts The {@link QueryPart} objects that are rendered at the - * {numbered placeholder} locations - * @return The results from the executed query. This may be - * null if the database returned no records - * @throws DataAccessException if something went wrong executing the query - * @throws InvalidResultException if the query returned more than one record - */ + @Override @Support public final Record fetchOne(String sql, QueryPart... parts) throws DataAccessException, InvalidResultException { return resultQuery(sql, parts).fetchOne(); } - /** - * Execute a query holding plain SQL. - *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @return The results from the executed query - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final int execute(String sql) throws DataAccessException { return query(sql).execute(); } - /** - * Execute a new query holding plain SQL. - *

- * There must be as many bind variables contained in the SQL, as passed in - * the bindings parameter - *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @param bindings The bindings - * @return The results from the executed query - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final int execute(String sql, Object... bindings) throws DataAccessException { return query(sql, bindings).execute(); } - /** - * Execute a new query holding plain SQL. - *

- * Unlike {@link #execute(String, Object...)}, the SQL passed to this method - * should not contain any bind variables. Instead, you can pass - * {@link QueryPart} objects to the method which will be rendered at indexed - * locations of your SQL string as such: 

-     * // The following query
-     * execute("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
-     *
-     * // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
-     * select ?, 'test' from "DUAL"
-     *
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! One way to escape - * literals is to use {@link Factory#name(String...)} and similar methods - * - * @param sql The SQL clause, containing {numbered placeholders} where query - * parts can be injected - * @param parts The {@link QueryPart} objects that are rendered at the - * {numbered placeholder} locations - * @return The results from the executed query - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final int execute(String sql, QueryPart... parts) throws DataAccessException { return query(sql, parts).execute(); } - /** - * Create a new query holding plain SQL. - *

- * There must not be any binding variables contained in the SQL - *

- * Use this method, when you want to take advantage of the many ways to - * fetch results in jOOQ, using {@link ResultQuery}. Some examples: - *

- * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - *
{@link ResultQuery#fetchLazy()}Open a cursor and fetch records one by one
{@link ResultQuery#fetchInto(Class)}Fetch records into a custom POJO (optionally annotated with JPA - * annotations)
{@link ResultQuery#fetchInto(RecordHandler)}Fetch records into a custom callback (similar to Spring's RowMapper)
{@link ResultQuery#fetchLater()}Fetch records of a long-running query asynchronously
- *

- * Example (Postgres): - *

- * 

-     * String sql = "FETCH ALL IN \"\"";
Example - * (SQLite): - *

- * 

-     * String sql = "pragma table_info('my_table')";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @return An executable query - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final ResultQuery resultQuery(String sql) { return resultQuery(sql, new Object[0]); } - /** - * Create a new query holding plain SQL. - *

- * There must be as many bind variables contained in the SQL, as passed in - * the bindings parameter - *

- * Use this method, when you want to take advantage of the many ways to - * fetch results in jOOQ, using {@link ResultQuery}. Some examples: - *

- * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - *
{@link ResultQuery#fetchLazy()}Open a cursor and fetch records one by one
{@link ResultQuery#fetchInto(Class)}Fetch records into a custom POJO (optionally annotated with JPA - * annotations)
{@link ResultQuery#fetchInto(RecordHandler)}Fetch records into a custom callback (similar to Spring's RowMapper)
{@link ResultQuery#fetchLater()}Fetch records of a long-running query asynchronously
- *

- * Example (Postgres): - *

- * 

-     * String sql = "FETCH ALL IN \"\"";
Example - * (SQLite): - *

- * 

-     * String sql = "pragma table_info('my_table')";
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! - * - * @param sql The SQL - * @param bindings The bindings - * @return A query wrapping the plain SQL - */ + @Override @Support public final ResultQuery resultQuery(String sql, Object... bindings) { return new SQLResultQuery(configuration, sql, bindings); } - /** - * Create a new query holding plain SQL. - *

- * Unlike {@link #resultQuery(String, Object...)}, the SQL passed to this - * method should not contain any bind variables. Instead, you can pass - * {@link QueryPart} objects to the method which will be rendered at indexed - * locations of your SQL string as such: 

-     * // The following query
-     * resultQuery("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
-     *
-     * // Will render this SQL on an Oracle database with RenderNameStyle.QUOTED:
-     * select ?, 'test' from "DUAL"
-     *
- *

- * NOTE: When inserting plain SQL into jOOQ objects, you must - * guarantee syntax integrity. You may also create the possibility of - * malicious SQL injection. Be sure to properly use bind variables and/or - * escape literals when concatenated into SQL clauses! One way to escape - * literals is to use {@link Factory#name(String...)} and similar methods - * - * @param sql The SQL clause, containing {numbered placeholders} where query - * parts can be injected - * @param parts The {@link QueryPart} objects that are rendered at the - * {numbered placeholder} locations - * @return A query wrapping the plain SQL - */ + @Override @Support public final ResultQuery resultQuery(String sql, QueryPart... parts) { return new SQLResultQuery(configuration, sql, parts); @@ -1308,187 +494,55 @@ public class Executor implements Serializable { // XXX JDBC convenience methods // ------------------------------------------------------------------------- - /** - * Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ - * {@link Result}. - *

- * After fetching all data, the JDBC ResultSet will be closed. - *

- * Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a - * time, instead of load the entire ResultSet into a jOOQ - * Result at once. - * - * @param rs The JDBC ResultSet to fetch data from - * @return The resulting jOOQ Result - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Result fetch(ResultSet rs) throws DataAccessException { return fetchLazy(rs).fetch(); } - /** - * Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ - * {@link Result}. - *

- * After fetching all data, the JDBC ResultSet will be - * closed. - *

- * Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a - * time, instead of load the entire ResultSet into a jOOQ - * Result at once. - *

- * The additional fields argument is used by jOOQ to coerce - * field names and data types to the desired output - * - * @param rs The JDBC ResultSet to fetch data from - * @param fields The fields to use in the desired output - * @return The resulting jOOQ Result - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Result fetch(ResultSet rs, Field... fields) throws DataAccessException { return fetchLazy(rs, fields).fetch(); } - /** - * Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ - * {@link Result}. - *

- * After fetching all data, the JDBC ResultSet will be - * closed. - *

- * Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a - * time, instead of load the entire ResultSet into a jOOQ - * Result at once. - *

- * The additional types argument is used by jOOQ to coerce - * data types to the desired output - * - * @param rs The JDBC ResultSet to fetch data from - * @param types The data types to use in the desired output - * @return The resulting jOOQ Result - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Result fetch(ResultSet rs, DataType... types) throws DataAccessException { return fetchLazy(rs, types).fetch(); } - /** - * Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ - * {@link Result}. - *

- * After fetching all data, the JDBC ResultSet will be - * closed. - *

- * Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a - * time, instead of load the entire ResultSet into a jOOQ - * Result at once. - *

- * The additional types argument is used by jOOQ to coerce - * data types to the desired output - * - * @param rs The JDBC ResultSet to fetch data from - * @param types The data types to use in the desired output - * @return The resulting jOOQ Result - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Result fetch(ResultSet rs, Class... types) throws DataAccessException { return fetchLazy(rs, types).fetch(); } - /** - * Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ - * {@link Record}. - *

- * This will internally fetch all records and throw an - * exception if there was more than one resulting record. - * - * @param rs The JDBC ResultSet to fetch data from - * @return The resulting jOOQ record - * @throws DataAccessException if something went wrong executing the query - * @throws InvalidResultException if the query returned more than one record - */ + @Override @Support public final Record fetchOne(ResultSet rs) throws DataAccessException, InvalidResultException { return Utils.fetchOne(fetchLazy(rs)); } - /** - * Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ - * {@link Record}. - *

- * This will internally fetch all records and throw an - * exception if there was more than one resulting record. - *

- * The additional fields argument is used by jOOQ to coerce - * field names and data types to the desired output - * - * @param rs The JDBC ResultSet to fetch data from - * @param fields The fields to use in the desired output - * @return The resulting jOOQ record - * @throws DataAccessException if something went wrong executing the query - * @throws InvalidResultException if the query returned more than one record - */ + @Override @Support public final Record fetchOne(ResultSet rs, Field... fields) throws DataAccessException, InvalidResultException { return Utils.fetchOne(fetchLazy(rs, fields)); } - /** - * Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ - * {@link Record}. - *

- * This will internally fetch all records and throw an - * exception if there was more than one resulting record. - *

- * The additional types argument is used by jOOQ to coerce - * data types to the desired output - * - * @param rs The JDBC ResultSet to fetch data from - * @param types The data types to use in the desired output - * @return The resulting jOOQ record - * @throws DataAccessException if something went wrong executing the query - * @throws InvalidResultException if the query returned more than one record - */ + @Override @Support public final Record fetchOne(ResultSet rs, DataType... types) throws DataAccessException, InvalidResultException { return Utils.fetchOne(fetchLazy(rs, types)); } - /** - * Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ - * {@link Record}. - *

- * This will internally fetch all records and throw an - * exception if there was more than one resulting record. - *

- * The additional types argument is used by jOOQ to coerce - * data types to the desired output - * - * @param rs The JDBC ResultSet to fetch data from - * @param types The data types to use in the desired output - * @return The resulting jOOQ record - * @throws DataAccessException if something went wrong executing the query - * @throws InvalidResultException if the query returned more than one record - */ + @Override @Support public final Record fetchOne(ResultSet rs, Class... types) throws DataAccessException, InvalidResultException { return Utils.fetchOne(fetchLazy(rs, types)); } - /** - * Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}. - *

- * Use {@link #fetch(ResultSet)}, to load the entire ResultSet - * into a jOOQ Result at once. - * - * @param rs The JDBC ResultSet to fetch data from - * @return The resulting jOOQ Result - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Cursor fetchLazy(ResultSet rs) throws DataAccessException { try { @@ -1499,20 +553,7 @@ public class Executor implements Serializable { } } - /** - * Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}. - *

- * Use {@link #fetch(ResultSet)}, to load the entire ResultSet - * into a jOOQ Result at once. - *

- * The additional fields argument is used by jOOQ to coerce - * field names and data types to the desired output - * - * @param rs The JDBC ResultSet to fetch data from - * @param fields The fields to use in the desired output - * @return The resulting jOOQ Result - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Cursor fetchLazy(ResultSet rs, Field... fields) throws DataAccessException { ExecuteContext ctx = new DefaultExecuteContext(configuration); @@ -1522,20 +563,7 @@ public class Executor implements Serializable { return new CursorImpl(ctx, listener, fields, null, true, false); } - /** - * Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}. - *

- * Use {@link #fetch(ResultSet)}, to load the entire ResultSet - * into a jOOQ Result at once. - *

- * The additional types argument is used by jOOQ to coerce - * data types to the desired output - * - * @param rs The JDBC ResultSet to fetch data from - * @param types The data types to use in the desired output - * @return The resulting jOOQ Result - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Cursor fetchLazy(ResultSet rs, DataType... types) throws DataAccessException { try { @@ -1554,159 +582,31 @@ public class Executor implements Serializable { } } - /** - * Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}. - *

- * Use {@link #fetch(ResultSet)}, to load the entire ResultSet - * into a jOOQ Result at once. - *

- * The additional types argument is used by jOOQ to coerce - * data types to the desired output - * - * @param rs The JDBC ResultSet to fetch data from - * @param types The data types to use in the desired output - * @return The resulting jOOQ Result - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Cursor fetchLazy(ResultSet rs, Class... types) throws DataAccessException { return fetchLazy(rs, Utils.getDataTypes(types)); } - /** - * Fetch all data from a formatted string. - *

- * The supplied string is supposed to be formatted in the following, - * human-readable way: 

-     * COL1  COL2   COL3 containing whitespace
-     * ----- ----   --------------------------
-     * val1  1      some text
-     * val2   2      more text
-     *
This method will decode the above formatted string - * according to the following rules: - *
    - *
  • The number of columns is defined by the number of dash groups in the - * second line
    • - *
  • The column types are VARCHAR(N) where - * N = number of dashes per dash group
    • - *
  • The column names are defined by the trimmed text contained in the - * first row
    • - *
  • The data is defined by the trimmed text contained in the subsequent - * rows
    • - *
- *

- * This is the same as calling {@link #fetchFromTXT(String, String)} with - * "{null}" as nullLiteral - *

- * A future version of jOOQ will also support the inverse operation of - * {@link Result#format()} through this method - * - * @param string The formatted string - * @return The transformed result - * @see #fetchFromTXT(String, String) - * @throws DataAccessException If the supplied string does not adhere to the - * above format rules. - */ + @Override @Support public final Result fetchFromTXT(String string) throws DataAccessException { return fetchFromTXT(string, "{null}"); } - /** - * Fetch all data from a formatted string. - *

- * The supplied string is supposed to be formatted in the following, - * human-readable way: 

-     * COL1  COL2   COL3 containing whitespace
-     * ----- ----   --------------------------
-     * val1  1      some text
-     * val2   2      more text
-     *
This method will decode the above formatted string - * according to the following rules: - *
    - *
  • The number of columns is defined by the number of dash groups in the - * second line
    • - *
  • The column types are VARCHAR(N) where - * N = number of dashes per dash group
    • - *
  • The column names are defined by the trimmed text contained in the - * first row
    • - *
  • The data is defined by the trimmed text contained in the subsequent - * rows
    • - *
- *

- * A future version of jOOQ will also support the inverse operation of - * {@link Result#format()} through this method - * - * @param string The formatted string - * @param nullLiteral The string literal to be used as null - * value. - * @return The transformed result - * @throws DataAccessException If the supplied string does not adhere to the - * above format rules. - */ + @Override @Support public final Result fetchFromTXT(String string, String nullLiteral) throws DataAccessException { return fetchFromStringData(Utils.parseTXT(string, nullLiteral)); } - /** - * Fetch all data from a CSV string. - *

- * This is the same as calling fetchFromCSV(string, ',') and - * the inverse of calling {@link Result#formatCSV()}. The first row of the - * CSV data is required to hold field name information. Subsequent rows may - * contain data, which is interpreted as {@link String}. Use the various - * conversion methods to retrieve other data types from the - * Result: - *

    - *
  • {@link Result#getValues(Field, Class)}
    • - *
  • {@link Result#getValues(int, Class)}
    • - *
  • {@link Result#getValues(String, Class)}
    • - *
  • {@link Result#getValues(Field, Converter)}
    • - *
  • {@link Result#getValues(int, Converter)}
    • - *
  • {@link Result#getValues(String, Converter)}
    • - *
- *

- * Missing values result in null. Empty values result in empty - * Strings - * - * @param string The CSV string - * @return The transformed result - * @throws DataAccessException If anything went wrong parsing the CSV file - * @see #fetchFromCSV(String, char) - */ + @Override @Support public final Result fetchFromCSV(String string) throws DataAccessException { return fetchFromCSV(string, ','); } - /** - * Fetch all data from a CSV string. - *

- * This is inverse of calling {@link Result#formatCSV(char)}. The first row - * of the CSV data is required to hold field name information. Subsequent - * rows may contain data, which is interpreted as {@link String}. Use the - * various conversion methods to retrieve other data types from the - * Result: - *

    - *
  • {@link Result#getValues(Field, Class)}
    • - *
  • {@link Result#getValues(int, Class)}
    • - *
  • {@link Result#getValues(String, Class)}
    • - *
  • {@link Result#getValues(Field, Converter)}
    • - *
  • {@link Result#getValues(int, Converter)}
    • - *
  • {@link Result#getValues(String, Converter)}
    • - *
- *

- * Missing values result in null. Empty values result in empty - * Strings - * - * @param string The CSV string - * @param delimiter The delimiter to expect between records - * @return The transformed result - * @throws DataAccessException If anything went wrong parsing the CSV file - * @see #fetchFromCSV(String) - * @see #fetchFromStringData(List) - */ + @Override @Support public final Result fetchFromCSV(String string, char delimiter) throws DataAccessException { CSVReader reader = new CSVReader(new StringReader(string), delimiter); @@ -1728,43 +628,12 @@ public class Executor implements Serializable { return fetchFromStringData(data); } - /** - * Fetch all data from a list of strings. - *

- * This is used by methods such as - *

    - *
  • {@link #fetchFromCSV(String)}
    • - *
  • {@link #fetchFromTXT(String)}
    • - *
- * The first element of the argument list should contain column names. - * Subsequent elements contain actual data. The degree of all arrays - * contained in the argument should be the same, although this is not a - * requirement. jOOQ will ignore excess data, and fill missing data with null. - * - * @param data The data to be transformed into a Result - * @return The transformed result - * @see #fetchFromStringData(List) - */ + @Override public final Result fetchFromStringData(String[]... data) { return fetchFromStringData(list(data)); } - /** - * Fetch all data from a list of strings. - *

- * This is used by methods such as - *

    - *
  • {@link #fetchFromCSV(String)}
    • - *
  • {@link #fetchFromTXT(String)}
    • - *
- * The first element of the argument list should contain column names. - * Subsequent elements contain actual data. The degree of all arrays - * contained in the argument should be the same, although this is not a - * requirement. jOOQ will ignore excess data, and fill missing data with null. - * - * @param data The data to be transformed into a Result - * @return The transformed result - */ + @Override public final Result fetchFromStringData(List data) { if (data.size() == 0) { return new ResultImpl(configuration); @@ -1798,13 +667,7 @@ public class Executor implements Serializable { // XXX Global Query factory // ------------------------------------------------------------------------- - /** - * Create a new DSL select statement. - *

- * Example: 

-     * SELECT * FROM [table] WHERE [conditions] ORDER BY [ordering] LIMIT [limit clause]
-     *
- */ + @Override @Support public final SelectWhereStep selectFrom(Table table) { SelectWhereStep result = Factory.selectFrom(table); @@ -1812,27 +675,7 @@ public class Executor implements Serializable { return result; } - /** - * Create a new DSL select statement. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Collection)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(fields)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#select(Collection) - */ + @Override @Support public final SelectSelectStep select(Collection> fields) { SelectSelectStep result = Factory.select(fields); @@ -1840,28 +683,7 @@ public class Executor implements Serializable { return result; } - /** - * Create a new DSL select statement. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field...)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2)
-     *       .execute();
-     *
- * - * @see Factory#select(Field...) - */ + @Override @Support public final SelectSelectStep select(Field... fields) { SelectSelectStep result = Factory.select(fields); @@ -1871,755 +693,141 @@ public class Executor implements Serializable { // [jooq-tools] START [select] - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Field#in(Select)}, {@link Field#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1) { return (SelectSelectStep) select(new Field[] { field1 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row2#in(Select)}, {@link Row2#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2) { return (SelectSelectStep) select(new Field[] { field1, field2 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row3#in(Select)}, {@link Row3#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3) { return (SelectSelectStep) select(new Field[] { field1, field2, field3 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row4#in(Select)}, {@link Row4#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, field4)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row5#in(Select)}, {@link Row5#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, field4, field5)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row6#in(Select)}, {@link Row6#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field5, field6)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row7#in(Select)}, {@link Row7#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field6, field7)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row8#in(Select)}, {@link Row8#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field7, field8)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row9#in(Select)}, {@link Row9#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field8, field9)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row10#in(Select)}, {@link Row10#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field9, field10)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row11#in(Select)}, {@link Row11#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field10, field11)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row12#in(Select)}, {@link Row12#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field11, field12)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row13#in(Select)}, {@link Row13#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field12, field13)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row14#in(Select)}, {@link Row14#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field13, field14)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row15#in(Select)}, {@link Row15#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field14, field15)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row16#in(Select)}, {@link Row16#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field15, field16)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row17#in(Select)}, {@link Row17#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field16, field17)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row18#in(Select)}, {@link Row18#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field17, field18)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row19#in(Select)}, {@link Row19#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field18, field19)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row20#in(Select)}, {@link Row20#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field19, field20)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row21#in(Select)}, {@link Row21#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field20, field21)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #select(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row22#in(Select)}, {@link Row22#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.select(field1, field2, field3, .., field21, field22)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21, Field field22) { return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 }); } // [jooq-tools] END [select] - /** - * Create a new DSL select statement. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Collection)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(fields)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Collection) - */ + @Override @Support public final SelectSelectStep selectDistinct(Collection> fields) { SelectSelectStep result = Factory.selectDistinct(fields); @@ -2627,27 +835,7 @@ public class Executor implements Serializable { return result; } - /** - * Create a new DSL select statement. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field...)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - */ + @Override @Support public final SelectSelectStep selectDistinct(Field... fields) { SelectSelectStep result = Factory.selectDistinct(fields); @@ -2657,756 +845,141 @@ public class Executor implements Serializable { // [jooq-tools] START [selectDistinct] - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Field#in(Select)}, {@link Field#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1) { return (SelectSelectStep) selectDistinct(new Field[] { field1 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row2#in(Select)}, {@link Row2#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row3#in(Select)}, {@link Row3#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row4#in(Select)}, {@link Row4#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, field4)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row5#in(Select)}, {@link Row5#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, field4, field5)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row6#in(Select)}, {@link Row6#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field5, field6)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row7#in(Select)}, {@link Row7#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field6, field7)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row8#in(Select)}, {@link Row8#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field7, field8)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row9#in(Select)}, {@link Row9#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field8, field9)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row10#in(Select)}, {@link Row10#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field9, field10)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row11#in(Select)}, {@link Row11#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field10, field11)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row12#in(Select)}, {@link Row12#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field11, field12)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row13#in(Select)}, {@link Row13#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field12, field13)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row14#in(Select)}, {@link Row14#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field13, field14)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row15#in(Select)}, {@link Row15#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field14, field15)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row16#in(Select)}, {@link Row16#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field15, field16)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row17#in(Select)}, {@link Row17#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field16, field17)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row18#in(Select)}, {@link Row18#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field17, field18)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row19#in(Select)}, {@link Row19#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field18, field19)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row20#in(Select)}, {@link Row20#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field19, field20)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row21#in(Select)}, {@link Row21#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field20, field21)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21 }); } - /** - * Create a new DSL select statement. - *

- * This is the same as {@link #selectDistinct(Field...)}, except that it - * declares additional record-level typesafety, which is needed by - * {@link Row22#in(Select)}, {@link Row22#equal(Select)} and other predicate - * building methods taking subselect arguments. - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectDistinct(field1, field2, field3, .., field21, field22)
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectDistinct(Field...) - * @see #selectDistinct(Field...) - */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final SelectSelectStep> selectDistinct(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21, Field field22) { return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 }); } // [jooq-tools] END [selectDistinct] - /** - * Create a new DSL select statement for constant 0 literal - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectZero()} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectZero()
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#zero() - * @see Factory#selectZero() - */ + @Override @Support public final SelectSelectStep> selectZero() { SelectSelectStep> result = Factory.selectZero(); @@ -3414,28 +987,7 @@ public class Executor implements Serializable { return result; } - /** - * Create a new DSL select statement for constant 1 literal - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectOne()} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectOne()
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#one() - * @see Factory#selectOne() - */ + @Override @Support public final SelectSelectStep> selectOne() { SelectSelectStep> result = Factory.selectOne(); @@ -3443,27 +995,7 @@ public class Executor implements Serializable { return result; } - /** - * Create a new DSL select statement for COUNT(*) - *

- * This creates an attached, renderable and executable SELECT - * statement from this {@link Executor}. If you don't need to render or - * execute this SELECT statement (e.g. because you want to - * create a subselect), consider using the static - * {@link Factory#selectCount()} instead. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.selectCount()
-     *       .from(table1)
-     *       .join(table2).on(field1.equal(field2))
-     *       .where(field1.greaterThan(100))
-     *       .orderBy(field2);
-     *
- * - * @see Factory#selectCount() - */ + @Override @Support public final SelectSelectStep> selectCount() { SelectSelectStep> result = Factory.selectCount(); @@ -3471,56 +1003,25 @@ public class Executor implements Serializable { return result; } - /** - * Create a new {@link SelectQuery} - */ + @Override @Support public final SelectQuery selectQuery() { return new SelectQueryImpl(configuration); } - /** - * Create a new {@link SelectQuery} - * - * @param table The table to select data from - * @return The new {@link SelectQuery} - */ + @Override @Support public final SelectQuery selectQuery(TableLike table) { return new SelectQueryImpl(configuration, table); } - /** - * Create a new {@link InsertQuery} - * - * @param into The table to insert data into - * @return The new {@link InsertQuery} - */ + @Override @Support public final InsertQuery insertQuery(Table into) { return new InsertQueryImpl(configuration, into); } - /** - * Create a new DSL insert statement. This type of insert may feel more - * convenient to some users, as it uses the UPDATE statement's - * SET a = b syntax. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table)
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .newRecord()
-     *       .set(field1, value3)
-     *       .set(field2, value4)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ + @Override @Support public final InsertSetStep insertInto(Table into) { return new InsertImpl(configuration, into, Collections.>emptyList()); @@ -3528,623 +1029,165 @@ public class Executor implements Serializable { // [jooq-tools] START [insert] - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1)
-     *       .values(field1)
-     *       .values(field1)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep1 insertInto(Table into, Field field1) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2)
-     *       .values(field1, field2)
-     *       .values(field1, field2)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep2 insertInto(Table into, Field field1, Field field2) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3)
-     *       .values(field1, field2, field3)
-     *       .values(field1, field2, field3)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep3 insertInto(Table into, Field field1, Field field2, Field field3) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, field4)
-     *       .values(field1, field2, field3, field4)
-     *       .values(field1, field2, field3, field4)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep4 insertInto(Table into, Field field1, Field field2, Field field3, Field field4) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, field4, field5)
-     *       .values(field1, field2, field3, field4, field5)
-     *       .values(field1, field2, field3, field4, field5)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep5 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field5, field6)
-     *       .values(valueA1, valueA2, valueA3, .., valueA5, valueA6)
-     *       .values(valueB1, valueB2, valueB3, .., valueB5, valueB6)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep6 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field6, field7)
-     *       .values(valueA1, valueA2, valueA3, .., valueA6, valueA7)
-     *       .values(valueB1, valueB2, valueB3, .., valueB6, valueB7)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep7 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field7, field8)
-     *       .values(valueA1, valueA2, valueA3, .., valueA7, valueA8)
-     *       .values(valueB1, valueB2, valueB3, .., valueB7, valueB8)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep8 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field8, field9)
-     *       .values(valueA1, valueA2, valueA3, .., valueA8, valueA9)
-     *       .values(valueB1, valueB2, valueB3, .., valueB8, valueB9)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep9 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field9, field10)
-     *       .values(valueA1, valueA2, valueA3, .., valueA9, valueA10)
-     *       .values(valueB1, valueB2, valueB3, .., valueB9, valueB10)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep10 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field10, field11)
-     *       .values(valueA1, valueA2, valueA3, .., valueA10, valueA11)
-     *       .values(valueB1, valueB2, valueB3, .., valueB10, valueB11)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep11 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field11, field12)
-     *       .values(valueA1, valueA2, valueA3, .., valueA11, valueA12)
-     *       .values(valueB1, valueB2, valueB3, .., valueB11, valueB12)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep12 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field12, field13)
-     *       .values(valueA1, valueA2, valueA3, .., valueA12, valueA13)
-     *       .values(valueB1, valueB2, valueB3, .., valueB12, valueB13)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep13 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field13, field14)
-     *       .values(valueA1, valueA2, valueA3, .., valueA13, valueA14)
-     *       .values(valueB1, valueB2, valueB3, .., valueB13, valueB14)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep14 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field14, field15)
-     *       .values(valueA1, valueA2, valueA3, .., valueA14, valueA15)
-     *       .values(valueB1, valueB2, valueB3, .., valueB14, valueB15)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep15 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field15, field16)
-     *       .values(valueA1, valueA2, valueA3, .., valueA15, valueA16)
-     *       .values(valueB1, valueB2, valueB3, .., valueB15, valueB16)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep16 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field16, field17)
-     *       .values(valueA1, valueA2, valueA3, .., valueA16, valueA17)
-     *       .values(valueB1, valueB2, valueB3, .., valueB16, valueB17)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep17 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field17, field18)
-     *       .values(valueA1, valueA2, valueA3, .., valueA17, valueA18)
-     *       .values(valueB1, valueB2, valueB3, .., valueB17, valueB18)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep18 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field18, field19)
-     *       .values(valueA1, valueA2, valueA3, .., valueA18, valueA19)
-     *       .values(valueB1, valueB2, valueB3, .., valueB18, valueB19)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep19 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field19, field20)
-     *       .values(valueA1, valueA2, valueA3, .., valueA19, valueA20)
-     *       .values(valueB1, valueB2, valueB3, .., valueB19, valueB20)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep20 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field20, field21)
-     *       .values(valueA1, valueA2, valueA3, .., valueA20, valueA21)
-     *       .values(valueB1, valueB2, valueB3, .., valueB20, valueB21)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep21 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21 })); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2, field3, .., field21, field22)
-     *       .values(valueA1, valueA2, valueA3, .., valueA21, valueA22)
-     *       .values(valueB1, valueB2, valueB3, .., valueB21, valueB22)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ @Generated("This method was generated using jOOQ-tools") - @Support + @Override public final InsertValuesStep22 insertInto(Table into, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21, Field field22) { return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 })); } // [jooq-tools] END [insert] - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2)
-     *       .values(value1, value2)
-     *       .values(value3, value4)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ + @Override @Support public final InsertValuesStepN insertInto(Table into, Field... fields) { return new InsertImpl(configuration, into, Arrays.asList(fields)); } - /** - * Create a new DSL insert statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.insertInto(table, field1, field2)
-     *       .values(value1, value2)
-     *       .values(value3, value4)
-     *       .onDuplicateKeyUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .execute();
-     *
- */ + @Override @Support public final InsertValuesStepN insertInto(Table into, Collection> fields) { return new InsertImpl(configuration, into, fields); } - /** - * Create a new {@link UpdateQuery} - * - * @param table The table to update data into - * @return The new {@link UpdateQuery} - */ + @Override @Support public final UpdateQuery updateQuery(Table table) { return new UpdateQueryImpl(configuration, table); } - /** - * Create a new DSL update statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.update(table)
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .where(field1.greaterThan(100))
-     *       .execute();
-     *
- *

- * Note that some databases support table expressions more complex than - * simple table references. In CUBRID and MySQL, for instance, you can write - * 

-     * create.update(t1.join(t2).on(t1.id.eq(t2.id)))
-     *       .set(t1.value, value1)
-     *       .set(t2.value, value2)
-     *       .where(t1.id.eq(10))
-     *       .execute();
-     *
- */ + @Override @Support public final UpdateSetFirstStep update(Table table) { return new UpdateImpl(configuration, table); } - /** - * Create a new DSL SQL standard MERGE statement. - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - *
dialectsupport typedocumentation
CUBRIDSQL:2008 standard and some enhancementshttp://www.cubrid.org/manual/90/en/MERGE
DB2SQL:2008 standard and major enhancementshttp://publib.boulder.ibm.com/infocenter/db2luw/v9/index.jsp?topic=/com. - * ibm.db2.udb.admin.doc/doc/r0010873.htm
HSQLDBSQL:2008 standardhttp://hsqldb.org/doc/2.0/guide/dataaccess-chapt.html#N129BA
OracleSQL:2008 standard and minor enhancementshttp://download.oracle.com/docs/cd/B28359_01/server.111/b28286/ - * statements_9016.htm
SQL ServerSimilar to SQL:2008 standard with some major enhancementshttp://msdn.microsoft.com/de-de/library/bb510625.aspx
SybaseSimilar to SQL:2008 standard with some major enhancementshttp://dcx.sybase.com/1100/en/dbreference_en11/merge-statement.html
- *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.mergeInto(table)
-     *       .using(select)
-     *       .on(condition)
-     *       .whenMatchedThenUpdate()
-     *       .set(field1, value1)
-     *       .set(field2, value2)
-     *       .whenNotMatchedThenInsert(field1, field2)
-     *       .values(value1, value2)
-     *       .execute();
-     *
- *

- * Note: Using this method, you can also create an H2-specific MERGE - * statement without field specification. See also - * {@link #mergeInto(Table, Field...)} - */ + @Override @Support({ CUBRID, DB2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) public final MergeUsingStep mergeInto(Table table) { return new MergeImpl(configuration, table); @@ -4152,637 +1195,159 @@ public class Executor implements Serializable { // [jooq-tools] START [merge] - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep1 mergeInto(Table table, Field field1) { return new MergeImpl(configuration, table, Arrays.asList(field1)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep2 mergeInto(Table table, Field field1, Field field2) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep3 mergeInto(Table table, Field field1, Field field2, Field field3) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep4 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep5 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep6 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep7 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep8 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep9 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep10 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep11 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep12 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep13 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep14 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep15 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep16 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep17 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep18 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep19 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep20 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep21 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ @Generated("This method was generated using jOOQ-tools") - @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) + @Override public final MergeKeyStep22 mergeInto(Table table, Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12, Field field13, Field field14, Field field15, Field field16, Field field17, Field field18, Field field19, Field field20, Field field21, Field field22) { return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22)); } // [jooq-tools] END [merge] - /** - * Create a new DSL merge statement (H2-specific syntax) - *

- * This statement is available from DSL syntax only. It is known to be - * supported in some way by any of these dialects: - * - * - * - * - * - * - * - * - * - * - * - *
H2H2 natively supports this special syntaxwww.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL AnywhereThese databases can simulate the H2-specific MERGE statement using a - * standard SQL MERGE statement, without restrictionsSee {@link #mergeInto(Table)} for the standard MERGE statement
- */ + @Override @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) public final MergeKeyStepN mergeInto(Table table, Field... fields) { return mergeInto(table, Arrays.asList(fields)); } - /** - * Create a new DSL merge statement (H2-specific syntax) - * - * @see #mergeInto(Table, Field...) - */ + @Override @Support({ CUBRID, DB2, H2, HSQLDB, ORACLE, SQLSERVER, SYBASE }) public final MergeKeyStepN mergeInto(Table table, Collection> fields) { return new MergeImpl(configuration, table, fields); } - /** - * Create a new {@link DeleteQuery} - * - * @param table The table to delete data from - * @return The new {@link DeleteQuery} - */ + @Override @Support public final DeleteQuery deleteQuery(Table table) { return new DeleteQueryImpl(configuration, table); } - /** - * Create a new DSL delete statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.delete(table)
-     *       .where(field1.greaterThan(100))
-     *       .execute();
-     *
- */ + @Override @Support public final DeleteWhereStep delete(Table table) { return new DeleteImpl(configuration, table); @@ -4792,239 +1357,67 @@ public class Executor implements Serializable { // XXX Batch query execution // ------------------------------------------------------------------------- - /** - * Execute a set of queries in batch mode (without bind values). - *

- * This essentially runs the following logic: 

-     * Statement s = connection.createStatement();
-     *
-     * for (Query query : queries) {
-     *     s.addBatch(query.getSQL(true));
-     * }
-     *
-     * s.execute();
-     *
- * - * @see Statement#executeBatch() - */ + @Override @Support public final Batch batch(Query... queries) { return new BatchMultiple(configuration, queries); } - /** - * Execute a set of queries in batch mode (without bind values). - *

- * This essentially runs the following logic: 

-     * Statement s = connection.createStatement();
-     *
-     * for (Query query : queries) {
-     *     s.addBatch(query.getSQL(true));
-     * }
-     *
-     * s.execute();
-     *
- * - * @see Statement#executeBatch() - */ + @Override @Support public final Batch batch(Collection queries) { return batch(queries.toArray(new Query[queries.size()])); } - /** - * Execute a set of queries in batch mode (with bind values). - *

- * When running 

-     * create.batch(query)
-     *       .bind(valueA1, valueA2)
-     *       .bind(valueB1, valueB2)
-     *       .execute();
-     *
- *

- * This essentially runs the following logic: 

-     * Statement s = connection.prepareStatement(query.getSQL(false));
-     *
-     * for (Object[] bindValues : allBindValues) {
-     *     for (Object bindValue : bindValues) {
-     *         s.setXXX(bindValue);
-     *     }
-     *
-     *     s.addBatch();
-     * }
-     *
-     * s.execute();
-     *
- *

- * Note: bind values will be inlined to a static batch query as in - * {@link #batch(Query...)}, if you choose to execute queries with - * {@link Settings#getStatementType()} == {@link StatementType#STATIC_STATEMENT} - * - * @see Statement#executeBatch() - */ + @Override @Support public final BatchBindStep batch(Query query) { return new BatchSingle(configuration, query); } - /** - * Execute a set of INSERT and UPDATE queries in - * batch mode (with bind values). - *

- * This batch operation can be executed in two modes: - *

- *

With - * {@link Settings#getStatementType()} == {@link StatementType#PREPARED_STATEMENT} - * (the default)
- *

- * In this mode, record order is preserved as much as possible, as long as - * two subsequent records generate the same SQL (with bind variables). The - * number of executed batch operations corresponds to - * [number of distinct rendered SQL statements]. In the worst - * case, this corresponds to the number of total records. - *

- * The record type order is preserved in the way they are passed to this - * method. This is an example of how statements will be ordered: 

-     * // Let's assume, odd numbers result in INSERTs and even numbers in UPDATES
-     * // Let's also assume a[n] are all of the same type, just as b[n], c[n]...
-     * int[] result = create.batchStore(a1, a2, a3, b1, a4, c1, b3, a5)
-     *                      .execute();
-     *
The above results in result.length == 8 and - * the following 4 separate batch statements: - *
    - *
  1. INSERT a1, a3, a5
    2. - *
  2. UPDATE a2, a4
    3. - *
  3. INSERT b1, b3
    4. - *
  4. INSERT c1
    5. - *
- *

- *

With - * {@link Settings#getStatementType()} == {@link StatementType#STATIC_STATEMENT} - *
- *

- * This mode may be better for large and complex batch store operations, as - * the order of records is preserved entirely, and jOOQ can guarantee that - * only a single batch statement is serialised to the database. - * - * @see Statement#executeBatch() - */ + @Override @Support public final Batch batchStore(UpdatableRecord... records) { return new BatchCRUD(configuration, Action.STORE, records); } - /** - * Execute a set of INSERT and UPDATE queries in - * batch mode (with bind values). - * - * @see #batchStore(UpdatableRecord...) - * @see Statement#executeBatch() - */ + @Override @Support public final Batch batchStore(Collection> records) { return batchStore(records.toArray(new UpdatableRecord[records.size()])); } - /** - * Execute a set of INSERT queries in batch mode (with bind - * values). - * - * @see #batchStore(UpdatableRecord...) - * @see Statement#executeBatch() - */ + @Override @Support public final Batch batchInsert(UpdatableRecord... records) { return new BatchCRUD(configuration, Action.INSERT, records); } - /** - * Execute a set of INSERT queries in batch mode (with bind - * values). - * - * @see #batchStore(UpdatableRecord...) - * @see Statement#executeBatch() - */ + @Override @Support public final Batch batchInsert(Collection> records) { return batchInsert(records.toArray(new UpdatableRecord[records.size()])); } - /** - * Execute a set of UPDATE queries in batch mode (with bind - * values). - * - * @see #batchStore(UpdatableRecord...) - * @see Statement#executeBatch() - */ + @Override @Support public final Batch batchUpdate(UpdatableRecord... records) { return new BatchCRUD(configuration, Action.UPDATE, records); } - /** - * Execute a set of UPDATE queries in batch mode (with bind - * values). - * - * @see #batchStore(UpdatableRecord...) - * @see Statement#executeBatch() - */ + @Override @Support public final Batch batchUpdate(Collection> records) { return batchUpdate(records.toArray(new UpdatableRecord[records.size()])); } - /** - * Execute a set of DELETE queries in batch mode (with bind - * values). - *

- * This batch operation can be executed in two modes: - *

- *

With - * {@link Settings#getStatementType()} == {@link StatementType#PREPARED_STATEMENT} - * (the default)
- *

- * In this mode, record order is preserved as much as possible, as long as - * two subsequent records generate the same SQL (with bind variables). The - * number of executed batch operations corresponds to - * [number of distinct rendered SQL statements]. In the worst - * case, this corresponds to the number of total records. - *

- * The record type order is preserved in the way they are passed to this - * method. This is an example of how statements will be ordered: 

-     * // Let's assume a[n] are all of the same type, just as b[n], c[n]...
-     * int[] result = create.batchStore(a1, a2, a3, b1, a4, c1, c2, a5)
-     *                      .execute();
-     *
The above results in result.length == 8 and - * the following 5 separate batch statements: - *
    - *
  1. DELETE a1, a2, a3
    2. - *
  2. DELETE b1
    3. - *
  3. DELETE a4
    4. - *
  4. DELETE c1, c2
    5. - *
  5. DELETE a5
    6. - *
- *

- *

With - * {@link Settings#getStatementType()} == {@link StatementType#STATIC_STATEMENT} - *
- *

- * This mode may be better for large and complex batch delete operations, as - * the order of records is preserved entirely, and jOOQ can guarantee that - * only a single batch statement is serialised to the database. - * - * @see Statement#executeBatch() - */ + @Override @Support public final Batch batchDelete(UpdatableRecord... records) { return new BatchCRUD(configuration, Action.DELETE, records); } - /** - * Execute a set of DELETE in batch mode (with bind values). - * - * @see #batchDelete(UpdatableRecord...) - * @see Statement#executeBatch() - */ + @Override @Support public final Batch batchDelete(Collection> records) { return batchDelete(records.toArray(new UpdatableRecord[records.size()])); @@ -5034,28 +1427,7 @@ public class Executor implements Serializable { // XXX DDL Statements // ------------------------------------------------------------------------- - /** - * Create a new DSL truncate statement. - *

- * Example: 

-     * Executor create = Factory.using();
-     *
-     * create.truncate(table)
-     *       .execute();
-     *
- *

- * Most dialects implement the TRUNCATE statement. If it is not - * supported, it is simulated using an equivalent DELETE - * statement. This is particularly true for these dialects: - *

    - *
  • {@link SQLDialect#FIREBIRD}
    • - *
  • {@link SQLDialect#INGRES}
    • - *
  • {@link SQLDialect#SQLITE}
    • - *
- *

- * Note, this statement is only supported in DSL mode. Immediate execution - * is omitted for future extensibility of this command. - */ + @Override @Support public final Truncate truncate(Table table) { return new TruncateImpl(configuration, table); @@ -5065,22 +1437,7 @@ public class Executor implements Serializable { // XXX Other queries for identites and sequences // ------------------------------------------------------------------------- - /** - * Retrieve the last inserted ID. - *

- * Note, there are some restrictions to the following dialects: - *

    - *
  • {@link SQLDialect#DB2} doesn't support this
    • - *
  • {@link SQLDialect#ORACLE} doesn't support this
    • - *
  • {@link SQLDialect#POSTGRES} doesn't support this
    • - *
  • {@link SQLDialect#SQLITE} supports this, but its support is poorly - * documented.
    • - *
- * - * @return The last inserted ID. This may be null in some - * dialects, if no such number is available. - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support({ ASE, CUBRID, DERBY, H2, HSQLDB, INGRES, MYSQL, SQLITE, SQLSERVER, SYBASE }) public final BigInteger lastID() throws DataAccessException { switch (configuration.getDialect()) { @@ -5123,84 +1480,21 @@ public class Executor implements Serializable { } } - /** - * Convenience method to fetch the NEXTVAL for a sequence directly from this - * {@link Executor}'s underlying JDBC {@link Connection} - * - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support({ CUBRID, DB2, DERBY, FIREBIRD, H2, HSQLDB, INGRES, ORACLE, POSTGRES, SYBASE }) public final T nextval(Sequence sequence) { Field nextval = sequence.nextval(); return select(nextval).fetchOne(nextval); } - /** - * Convenience method to fetch the CURRVAL for a sequence directly from this - * {@link Executor}'s underlying JDBC {@link Connection} - * - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support({ CUBRID, DB2, FIREBIRD, H2, INGRES, ORACLE, POSTGRES, SYBASE }) public final T currval(Sequence sequence) throws DataAccessException { Field currval = sequence.currval(); return select(currval).fetchOne(currval); } - /** - * Use a schema as the default schema of the underlying connection. - *

- * This has two effects. - *

    - *
  1. The USE [schema] statement is executed on those RDBMS - * that support this
    2. - *
  2. The supplied {@link Schema} is used as the default schema resulting - * in omitting that schema in rendered SQL.
    3. - *
- *

- * The USE [schema] statement translates to the various - * dialects as follows: - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - * - *
DialectCommand
DB2SET SCHEMA [schema]
Derby:SET SCHEMA [schema]
H2:SET SCHEMA [schema]
HSQLDB:SET SCHEMA [schema]
MySQL:USE [schema]
Oracle:ALTER SESSION SET CURRENT_SCHEMA = [schema]
Postgres:SET SEARCH_PATH = [schema]
Sybase:USE [schema]
- * - * @throws DataAccessException if something went wrong executing the query - */ + @Override @SuppressWarnings("deprecation") @Support({ DB2, DERBY, H2, HSQLDB, MYSQL, SYBASE, ORACLE, POSTGRES, SYBASE }) public final int use(Schema schema) throws DataAccessException { @@ -5250,12 +1544,7 @@ public class Executor implements Serializable { return result; } - /** - * Use a schema as the default schema of the underlying connection. - * - * @see #use(Schema) - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support({ DB2, DERBY, H2, HSQLDB, MYSQL, SYBASE, ORACLE, POSTGRES, SYBASE }) public final int use(String schema) throws DataAccessException { return use(new SchemaImpl(schema)); @@ -5265,78 +1554,24 @@ public class Executor implements Serializable { // XXX Global Record factory // ------------------------------------------------------------------------- - /** - * Create a new {@link UDTRecord}. - *

- * The resulting record is attached to this {@link Configuration} by - * default. Use {@link Settings#isAttachRecords()} to override this - * behaviour. - * - * @param The generic record type - * @param type The UDT describing records of type <R> - * @return The new record - */ + @Override public final > R newRecord(UDT type) { return Utils.newRecord(type, configuration); } - /** - * Create a new {@link Record} that can be inserted into the corresponding - * table. - *

- * The resulting record is attached to this {@link Configuration} by - * default. Use {@link Settings#isAttachRecords()} to override this - * behaviour. - * - * @param The generic record type - * @param table The table holding records of type <R> - * @return The new record - */ + @Override public final R newRecord(Table table) { return Utils.newRecord(table, configuration); } - /** - * Create a new pre-filled {@link Record} that can be inserted into the - * corresponding table. - *

- * This performs roughly the inverse operation of {@link Record#into(Class)} - *

- * The resulting record will have its internal "changed" flags set to true - * for all values. This means that {@link UpdatableRecord#store()} will - * perform an INSERT statement. If you wish to store the record - * using an UPDATE statement, use - * {@link #executeUpdate(UpdatableRecord)} instead. - *

- * The resulting record is attached to this {@link Configuration} by - * default. Use {@link Settings#isAttachRecords()} to override this - * behaviour. - * - * @param The generic record type - * @param table The table holding records of type <R> - * @param source The source to be used to fill the new record - * @return The new record - * @throws MappingException wrapping any reflection or data type conversion - * exception that might have occurred while mapping records - * @see Record#from(Object) - * @see Record#into(Class) - */ + @Override public final R newRecord(Table table, Object source) { R result = newRecord(table); result.from(source); return result; } - /** - * Create a new empty {@link Result}. - *

- * The result is attached to this {@link Configuration} by default. This - * result can be used as a container for records. - * - * @param The generic record type - * @param table The table holding records of type <R> - * @return The new result - */ + @Override public final Result newResult(Table table) { return new ResultImpl(configuration, table.fields()); } @@ -5345,15 +1580,7 @@ public class Executor implements Serializable { // XXX Executing queries // ------------------------------------------------------------------------- - /** - * Execute a {@link ResultQuery} in the context of this executor and return - * results. - * - * @param query The query to execute - * @return The result - * @throws DataAccessException if something went wrong executing the query - * @see ResultQuery#fetch() - */ + @Override public final Result fetch(ResultQuery query) throws DataAccessException { final Configuration previous = Utils.getConfiguration(query); @@ -5366,15 +1593,7 @@ public class Executor implements Serializable { } } - /** - * Execute a {@link ResultQuery} in the context of this executor and return - * a cursor. - * - * @param query The query to execute - * @return The cursor - * @throws DataAccessException if something went wrong executing the query - * @see ResultQuery#fetchLazy() - */ + @Override public final Cursor fetchLazy(ResultQuery query) throws DataAccessException { final Configuration previous = Utils.getConfiguration(query); @@ -5387,15 +1606,7 @@ public class Executor implements Serializable { } } - /** - * Execute a {@link ResultQuery} in the context of this executor and return - * a cursor. - * - * @param query The query to execute - * @return The results - * @throws DataAccessException if something went wrong executing the query - * @see ResultQuery#fetchMany() - */ + @Override public final List> fetchMany(ResultQuery query) throws DataAccessException { final Configuration previous = Utils.getConfiguration(query); @@ -5408,16 +1619,7 @@ public class Executor implements Serializable { } } - /** - * Execute a {@link ResultQuery} in the context of this executor and return - * a record. - * - * @param query The query to execute - * @return The record - * @throws DataAccessException if something went wrong executing the query - * @throws InvalidResultException if the query returned more than one record - * @see ResultQuery#fetchOne() - */ + @Override public final R fetchOne(ResultQuery query) throws DataAccessException, InvalidResultException { final Configuration previous = Utils.getConfiguration(query); @@ -5430,40 +1632,12 @@ public class Executor implements Serializable { } } - /** - * Execute a {@link Select} query in the context of this executor and return - * a COUNT(*) value. - *

- * This wraps a pre-existing SELECT query in another one to - * calculate the COUNT(*) value, without modifying the original - * SELECT. An example: 

-     * -- Original query:
-     * SELECT id, title FROM book WHERE title LIKE '%a%'
-     *
-     * -- Wrapped query:
-     * SELECT count(*) FROM (
-     *   SELECT id, title FROM book WHERE title LIKE '%a%'
-     * )
-     *
This is particularly useful for those databases that do not - * support the COUNT(*) OVER() window function to calculate - * total results in paged queries. - * - * @param query The wrapped query - * @return The COUNT(*) result - * @throws DataAccessException if something went wrong executing the query - */ + @Override public final int fetchCount(Select query) throws DataAccessException { return selectCount().from(query).fetchOne(0, int.class); } - /** - * Execute a {@link Query} in the context of this executor. - * - * @param query The query to execute - * @return The number of affected rows - * @throws DataAccessException if something went wrong executing the query - * @see Query#execute() - */ + @Override public final int execute(Query query) throws DataAccessException { final Configuration previous = Utils.getConfiguration(query); @@ -5480,130 +1654,49 @@ public class Executor implements Serializable { // XXX Fast querying // ------------------------------------------------------------------------- - /** - * Execute and return all records for - * 
SELECT * FROM [table]
 - *

- * The result and its contained records are attached to this - * {@link Configuration} by default. Use {@link Settings#isAttachRecords()} - * to override this behaviour. - * - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Result fetch(Table table) throws DataAccessException { return fetch(table, trueCondition()); } - /** - * Execute and return all records for - * 

SELECT * FROM [table] WHERE [condition]
- *

- * The result and its contained records are attached to this - * {@link Configuration} by default. Use {@link Settings#isAttachRecords()} - * to override this behaviour. - * - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Result fetch(Table table, Condition condition) throws DataAccessException { return selectFrom(table).where(condition).fetch(); } - /** - * Execute and return zero or one record for - * 

SELECT * FROM [table]
- *

- * The resulting record is attached to this {@link Configuration} by - * default. Use {@link Settings#isAttachRecords()} to override this - * behaviour. - * - * @return The record or null if no record was returned - * @throws DataAccessException if something went wrong executing the query - * @throws InvalidResultException if the query returned more than one record - */ + @Override @Support public final R fetchOne(Table table) throws DataAccessException, InvalidResultException { return Utils.fetchOne(fetchLazy(table)); } - /** - * Execute and return zero or one record for - * 

SELECT * FROM [table] WHERE [condition]
- *

- * The resulting record is attached to this {@link Configuration} by - * default. Use {@link Settings#isAttachRecords()} to override this - * behaviour. - * - * @return The record or null if no record was returned - * @throws DataAccessException if something went wrong executing the query - * @throws InvalidResultException if the query returned more than one record - */ + @Override @Support public final R fetchOne(Table table, Condition condition) throws DataAccessException, InvalidResultException { return Utils.fetchOne(fetchLazy(table, condition)); } - /** - * Execute and return zero or one record for - * 

SELECT * FROM [table] LIMIT 1
- *

- * The resulting record is attached to this {@link Configuration} by - * default. Use {@link Settings#isAttachRecords()} to override this - * behaviour. - * - * @return The record or null if no record was returned - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final R fetchAny(Table table) throws DataAccessException { return Utils.filterOne(selectFrom(table).limit(1).fetch()); } - /** - * Execute and return all records lazily for - * 

SELECT * FROM [table]
- *

- * The result and its contained records are attached to this - * {@link Configuration} by default. Use {@link Settings#isAttachRecords()} - * to override this behaviour. - * - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Cursor fetchLazy(Table table) throws DataAccessException { return fetchLazy(table, trueCondition()); } - /** - * Execute and return all records lazily for - * 

SELECT * FROM [table] WHERE [condition]
- *

- * The result and its contained records are attached to this - * {@link Configuration} by default. Use {@link Settings#isAttachRecords()} - * to override this behaviour. - * - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final Cursor fetchLazy(Table table, Condition condition) throws DataAccessException { return selectFrom(table).where(condition).fetchLazy(); } - /** - * Insert one record - *

- * This executes something like the following statement: - * 

INSERT INTO [table] ... VALUES [record]
- *

- * Unlike {@link UpdatableRecord#store()}, this does not change any of the - * argument record's internal "changed" flags, such that a - * subsequent call to {@link UpdatableRecord#store()} might lead to another - * INSERT statement being executed. - * - * @return The number of inserted records - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final > int executeInsert(R record) throws DataAccessException { InsertQuery insert = insertQuery(record.getTable()); @@ -5611,13 +1704,7 @@ public class Executor implements Serializable { return insert.execute(); } - /** - * Update a table - * 

UPDATE [table] SET [modified values in record] WHERE [record is supplied record]
- * - * @return The number of updated records - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final > int executeUpdate(R record) throws DataAccessException { UpdateQuery update = updateQuery(record.getTable()); @@ -5626,13 +1713,7 @@ public class Executor implements Serializable { return update.execute(); } - /** - * Update a table - * 
UPDATE [table] SET [modified values in record] WHERE [condition]
 - * - * @return The number of updated records - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final , T> int executeUpdate(R record, Condition condition) throws DataAccessException { UpdateQuery update = updateQuery(record.getTable()); @@ -5641,13 +1722,7 @@ public class Executor implements Serializable { return update.execute(); } - /** - * Delete a record from a table - * 
DELETE FROM [table] WHERE [record is supplied record]
 - * - * @return The number of deleted records - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final > int executeDelete(R record) throws DataAccessException { DeleteQuery delete = deleteQuery(record.getTable()); @@ -5655,13 +1730,7 @@ public class Executor implements Serializable { return delete.execute(); } - /** - * Delete a record from a table - * 
DELETE FROM [table] WHERE [condition]
 - * - * @return The number of deleted records - * @throws DataAccessException if something went wrong executing the query - */ + @Override @Support public final , T> int executeDelete(R record, Condition condition) throws DataAccessException { DeleteQuery delete = deleteQuery(record.getTable());