org.jooq.impl.DSL Maven / Gradle / Ivy
/**
* Copyright (c) 2009-2014, Data Geekery GmbH (http://www.datageekery.com)
* All rights reserved.
*
* This work is dual-licensed
* - under the Apache Software License 2.0 (the "ASL")
* - under the jOOQ License and Maintenance Agreement (the "jOOQ License")
* =============================================================================
* You may choose which license applies to you:
*
* - If you're using this work with Open Source databases, you may choose
* either ASL or jOOQ License.
* - If you're using this work with at least one commercial database, you must
* choose jOOQ License
*
* For more information, please visit http://www.jooq.org/licenses
*
* Apache Software License 2.0:
* -----------------------------------------------------------------------------
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* jOOQ License and Maintenance Agreement:
* -----------------------------------------------------------------------------
* Data Geekery grants the Customer the non-exclusive, timely limited and
* non-transferable license to install and use the Software under the terms of
* the jOOQ License and Maintenance Agreement.
*
* This library is distributed with a LIMITED WARRANTY. See the jOOQ License
* and Maintenance Agreement for more details: http://www.jooq.org/licensing
*/
package org.jooq.impl;
// ...
// ...
import static org.jooq.SQLDialect.CUBRID;
// ...
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.MARIADB;
import static org.jooq.SQLDialect.MYSQL;
// ...
// ...
// ...
import static org.jooq.SQLDialect.POSTGRES;
import static org.jooq.SQLDialect.SQLITE;
// ...
// ...
// ...
import static org.jooq.impl.Term.ROW_NUMBER;
import static org.jooq.impl.Utils.combine;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Properties;
import javax.annotation.Generated;
import javax.sql.DataSource;
import org.jooq.AggregateFunction;
import org.jooq.AlterSequenceRestartStep;
import org.jooq.AlterTableStep;
// ...
import org.jooq.Case;
import org.jooq.CommonTableExpression;
import org.jooq.Condition;
import org.jooq.Configuration;
import org.jooq.ConnectionProvider;
import org.jooq.CreateIndexStep;
import org.jooq.CreateSequenceFinalStep;
import org.jooq.CreateTableAsStep;
import org.jooq.CreateViewAsStep;
import org.jooq.DSLContext;
import org.jooq.DataType;
import org.jooq.DatePart;
import org.jooq.Delete;
import org.jooq.DeleteWhereStep;
import org.jooq.DerivedColumnList;
import org.jooq.DropIndexFinalStep;
import org.jooq.DropSequenceFinalStep;
import org.jooq.DropTableStep;
import org.jooq.DropViewFinalStep;
import org.jooq.Field;
import org.jooq.GroupConcatOrderByStep;
import org.jooq.GroupField;
import org.jooq.Insert;
import org.jooq.InsertSetStep;
import org.jooq.InsertValuesStep1;
import org.jooq.InsertValuesStep10;
import org.jooq.InsertValuesStep11;
import org.jooq.InsertValuesStep12;
import org.jooq.InsertValuesStep13;
import org.jooq.InsertValuesStep14;
import org.jooq.InsertValuesStep15;
import org.jooq.InsertValuesStep16;
import org.jooq.InsertValuesStep17;
import org.jooq.InsertValuesStep18;
import org.jooq.InsertValuesStep19;
import org.jooq.InsertValuesStep2;
import org.jooq.InsertValuesStep20;
import org.jooq.InsertValuesStep21;
import org.jooq.InsertValuesStep22;
import org.jooq.InsertValuesStep3;
import org.jooq.InsertValuesStep4;
import org.jooq.InsertValuesStep5;
import org.jooq.InsertValuesStep6;
import org.jooq.InsertValuesStep7;
import org.jooq.InsertValuesStep8;
import org.jooq.InsertValuesStep9;
import org.jooq.InsertValuesStepN;
import org.jooq.Keyword;
import org.jooq.Merge;
import org.jooq.MergeKeyStep1;
import org.jooq.MergeKeyStep10;
import org.jooq.MergeKeyStep11;
import org.jooq.MergeKeyStep12;
import org.jooq.MergeKeyStep13;
import org.jooq.MergeKeyStep14;
import org.jooq.MergeKeyStep15;
import org.jooq.MergeKeyStep16;
import org.jooq.MergeKeyStep17;
import org.jooq.MergeKeyStep18;
import org.jooq.MergeKeyStep19;
import org.jooq.MergeKeyStep2;
import org.jooq.MergeKeyStep20;
import org.jooq.MergeKeyStep21;
import org.jooq.MergeKeyStep22;
import org.jooq.MergeKeyStep3;
import org.jooq.MergeKeyStep4;
import org.jooq.MergeKeyStep5;
import org.jooq.MergeKeyStep6;
import org.jooq.MergeKeyStep7;
import org.jooq.MergeKeyStep8;
import org.jooq.MergeKeyStep9;
import org.jooq.MergeKeyStepN;
import org.jooq.MergeUsingStep;
import org.jooq.Name;
import org.jooq.OrderedAggregateFunction;
import org.jooq.Param;
import org.jooq.QuantifiedSelect;
import org.jooq.Query;
import org.jooq.QueryPart;
import org.jooq.Record;
import org.jooq.Record1;
import org.jooq.Record10;
import org.jooq.Record11;
import org.jooq.Record12;
import org.jooq.Record13;
import org.jooq.Record14;
import org.jooq.Record15;
import org.jooq.Record16;
import org.jooq.Record17;
import org.jooq.Record18;
import org.jooq.Record19;
import org.jooq.Record2;
import org.jooq.Record20;
import org.jooq.Record21;
import org.jooq.Record22;
import org.jooq.Record3;
import org.jooq.Record4;
import org.jooq.Record5;
import org.jooq.Record6;
import org.jooq.Record7;
import org.jooq.Record8;
import org.jooq.Record9;
import org.jooq.RecordHandler;
import org.jooq.Result;
import org.jooq.ResultQuery;
import org.jooq.Row1;
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.RowN;
import org.jooq.SQLDialect;
import org.jooq.Schema;
import org.jooq.Select;
import org.jooq.SelectSelectStep;
import org.jooq.SelectWhereStep;
import org.jooq.Sequence;
import org.jooq.SortField;
import org.jooq.Support;
import org.jooq.Table;
import org.jooq.TableLike;
import org.jooq.TruncateIdentityStep;
import org.jooq.UDTRecord;
import org.jooq.Update;
import org.jooq.UpdateSetFirstStep;
import org.jooq.WindowIgnoreNullsStep;
import org.jooq.WindowOverStep;
import org.jooq.WindowSpecification;
import org.jooq.WindowSpecificationFinalStep;
import org.jooq.WindowSpecificationOrderByStep;
import org.jooq.WindowSpecificationRowsAndStep;
import org.jooq.WindowSpecificationRowsStep;
import org.jooq.WithAsStep;
import org.jooq.WithStep;
import org.jooq.conf.RenderNameStyle;
import org.jooq.conf.Settings;
import org.jooq.exception.SQLDialectNotSupportedException;
import org.jooq.tools.Convert;
import org.jooq.tools.jdbc.JDBCUtils;
import org.jooq.types.DayToSecond;
/**
* A DSL "entry point" providing implementations to the org.jooq
* interfaces.
*
* The {@link DSLContext} and this DSL are the main entry point for
* client code, to access jOOQ classes and functionality. Here, you can
* instantiate all of those objects that cannot be accessed through other
* objects. For example, to create a {@link Field} representing a constant
* value, you can write:
*
*
* Field<String> field = DSL.val("Hello World")
*
* Another example is the EXISTS clause, which you can apply to any
* SELECT to form a {@link Condition}:
*
*
* Condition condition = DSL.exists(DSL.select(...));
*
*
DSL and static imports
*
* For increased fluency and readability of your jOOQ client code, it is
* recommended that you static import all methods from the DSL. For
* example:
* import static org.jooq.impl.DSL.*;
*
* public class Main {
* public static void main(String[] args) {
* DSL.select(val("Hello"), inline("World"));
* // DSL.val ^^^ ^^^^^^ DSL.inline
* }
* }
*
* In order to use the "contextual DSL", call one of the various overloaded
* {@link #using(Configuration)} methods:
*
*
* // Create and immediately execute a SELECT statement:
* DSL.using(connection, dialect)
* .selectOne()
* .fetch();
*
* 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
*/
public static DSLContext using(SQLDialect dialect) {
return new DefaultDSLContext(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
*/
public static DSLContext using(SQLDialect dialect, Settings settings) {
return new DefaultDSLContext(dialect, settings);
}
/**
* Create an executor from a JDBC connection URL.
*
* The connections created this way will be closed upon finalization. This
* is useful for standalone scripts, but not for managed connections.
*
* @param url The connection URL.
* @see DefaultConnectionProvider
* @see JDBCUtils#dialect(String)
*/
public static DSLContext using(String url) {
try {
Connection connection = DriverManager.getConnection(url);
return using(new DefaultConnectionProvider(connection, true), JDBCUtils.dialect(connection));
}
catch (SQLException e) {
throw Utils.translate("Error when initialising Connection", e);
}
}
/**
* Create an executor from a JDBC connection URL.
*
* The connections created this way will be closed upon finalization. This
* is useful for standalone scripts, but not for managed connections.
*
* @param url The connection URL.
* @param username The connection user name.
* @param password The connection password.
* @see DefaultConnectionProvider
* @see JDBCUtils#dialect(String)
*/
public static DSLContext using(String url, String username, String password) {
try {
Connection connection = DriverManager.getConnection(url, username, password);
return using(new DefaultConnectionProvider(connection, true), JDBCUtils.dialect(connection));
}
catch (SQLException e) {
throw Utils.translate("Error when initialising Connection", e);
}
}
/**
* Create an executor from a JDBC connection URL.
*
* The connections created this way will be closed upon finalization. This
* is useful for standalone scripts, but not for managed connections.
*
* @param url The connection URL.
* @param properties The connection properties.
* @see DefaultConnectionProvider
* @see JDBCUtils#dialect(String)
*/
public static DSLContext using(String url, Properties properties) {
try {
Connection connection = DriverManager.getConnection(url, properties);
return using(new DefaultConnectionProvider(connection, true), JDBCUtils.dialect(connection));
}
catch (SQLException e) {
throw Utils.translate("Error when initialising Connection", e);
}
}
/**
* Create an executor with a connection configured.
*
* If you provide a JDBC connection to a jOOQ Configuration, jOOQ will use
* that connection directly for creating statements.
*
* This is a convenience constructor for
* {@link #using(Connection, Settings)}, guessing the {@link SQLDialect}
* using {@link JDBCUtils#dialect(Connection)}
*
* @param connection The connection to use with objects created from this
* executor
* @see DefaultConnectionProvider
* @see JDBCUtils#dialect(Connection)
*/
public static DSLContext using(Connection connection) {
return new DefaultDSLContext(connection, JDBCUtils.dialect(connection), null);
}
/**
* Create an executor with a connection and a dialect configured.
*
* If you provide a JDBC connection to a jOOQ Configuration, jOOQ will use
* that connection directly for creating statements.
*
* This is a convenience constructor for
* {@link #using(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
*/
public static DSLContext using(Connection connection, SQLDialect dialect) {
return new DefaultDSLContext(connection, dialect, null);
}
/**
* Create an executor with a connection, a dialect and settings configured.
*
* If you provide a JDBC connection to a jOOQ Configuration, jOOQ will use
* that connection directly for creating statements.
*
* This is a convenience constructor for
* {@link #using(ConnectionProvider, SQLDialect, Settings)} using a
* {@link DefaultConnectionProvider} and guessing the {@link SQLDialect}
* using {@link JDBCUtils#dialect(Connection)}
*
* @param connection The connection to use with objects created from this
* executor
* @param settings The runtime settings to apply to objects created from
* this executor
* @see DefaultConnectionProvider
* @see JDBCUtils#dialect(Connection)
*/
public static DSLContext using(Connection connection, Settings settings) {
return new DefaultDSLContext(connection, JDBCUtils.dialect(connection), settings);
}
/**
* Create an executor with a connection, a dialect and settings configured.
*
* If you provide a JDBC connection to a jOOQ Configuration, jOOQ will use
* that connection directly for creating statements.
*
* This is a convenience constructor for
* {@link #using(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
*/
public static DSLContext using(Connection connection, SQLDialect dialect, Settings settings) {
return new DefaultDSLContext(connection, dialect, settings);
}
/**
* Create an executor with a data source and a dialect configured.
*
* If you provide a JDBC data source to a jOOQ Configuration, jOOQ will use
* that data source for initialising connections, and creating statements.
*
* This is a convenience constructor for
* {@link #using(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
*/
public static DSLContext using(DataSource datasource, SQLDialect dialect) {
return new DefaultDSLContext(datasource, dialect);
}
/**
* Create an executor with a data source, a dialect and settings configured.
*
* If you provide a JDBC data source to a jOOQ Configuration, jOOQ will use
* that data source for initialising connections, and creating statements.
*
* This is a convenience constructor for
* {@link #using(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
*/
public static DSLContext using(DataSource datasource, SQLDialect dialect, Settings settings) {
return new DefaultDSLContext(datasource, dialect, settings);
}
/**
* 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
*/
public static DSLContext using(ConnectionProvider connectionProvider, SQLDialect dialect) {
return new DefaultDSLContext(connectionProvider, dialect);
}
/**
* 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
*/
public static DSLContext using(ConnectionProvider connectionProvider, SQLDialect dialect, Settings settings) {
return new DefaultDSLContext(connectionProvider, dialect, settings);
}
/**
* Create an executor from a custom configuration.
*
* @param configuration The configuration
*/
public static DSLContext using(Configuration configuration) {
return new DefaultDSLContext(configuration);
}
// -------------------------------------------------------------------------
// XXX Static subselect factory methods
// -------------------------------------------------------------------------
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(String)} for strictly non-recursive CTE
* and {@link #withRecursive(String)} for strictly
* recursive CTE.
*/
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep with(String alias) {
return new WithImpl(null, false).with(alias);
}
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(String, String...)} for strictly non-recursive CTE
* and {@link #withRecursive(String, String...)} for strictly
* recursive CTE.
*/
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep with(String alias, String... fieldAliases) {
return new WithImpl(null, false).with(alias, fieldAliases);
}
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* Reusable {@link CommonTableExpression} types can be constructed through
*
* - {@link #name(String...)}
* - {@link Name#fields(String...)}
* -
* {@link DerivedColumnList#as(Select)}
*
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(CommonTableExpression...)} for strictly non-recursive CTE
* and {@link #withRecursive(CommonTableExpression...)} for strictly
* recursive CTE.
*/
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithStep with(CommonTableExpression... tables) {
return new WithImpl(null, false).with(tables);
}
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(String)} for strictly non-recursive CTE
* and {@link #withRecursive(String)} for strictly
* recursive CTE.
*
* Note that the {@link SQLDialect#H2} database only supports single-table,
* RECURSIVE common table expression lists.
*/
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep withRecursive(String alias) {
return new WithImpl(null, true).with(alias);
}
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(String, String...)} for strictly non-recursive CTE
* and {@link #withRecursive(String, String...)} for strictly
* recursive CTE.
*
* Note that the {@link SQLDialect#H2} database only supports single-table,
* RECURSIVE common table expression lists.
*/
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep withRecursive(String alias, String... fieldAliases) {
return new WithImpl(null, true).with(alias, fieldAliases);
}
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* Reusable {@link CommonTableExpression} types can be constructed through
*
* - {@link #name(String...)}
* - {@link Name#fields(String...)}
* -
* {@link DerivedColumnList#as(Select)}
*
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(CommonTableExpression...)} for strictly non-recursive CTE
* and {@link #withRecursive(CommonTableExpression...)} for strictly
* recursive CTE.
*
* Note that the {@link SQLDialect#H2} database only supports single-table,
* RECURSIVE common table expression lists.
*/
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithStep withRecursive(CommonTableExpression... tables) {
return new WithImpl(null, true).with(tables);
}
/**
* Create a new DSL select statement.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* SELECT * FROM [table] WHERE [conditions] ORDER BY [ordering] LIMIT [limit clause]
* SelectWhereStep selectFrom(Table table) {
return new SelectImpl(null, new DefaultConfiguration()).from(table);
}
/**
* Create a new DSL subselect statement.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(fields)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* select(Collection> fields) {
return new SelectImpl(null, new DefaultConfiguration()).select(fields);
}
/**
* Create a new DSL subselect statement.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* select(Field... fields) {
return new SelectImpl(null, new DefaultConfiguration()).select(fields);
}
// [jooq-tools] START [select]
/**
* Create a new DSL subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1) {
return (SelectSelectStep) select(new Field[] { field1 });
}
/**
* Create a new DSL subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2) {
return (SelectSelectStep) select(new Field[] { field1, field2 });
}
/**
* Create a new DSL subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3) {
return (SelectSelectStep) select(new Field[] { field1, field2, field3 });
}
/**
* Create a new DSL subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, field4)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4) {
return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4 });
}
/**
* Create a new DSL subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, field4, field5)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field5, field6)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field6, field7)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field7, field8)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field8, field9)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field9, field10)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field10, field11)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field11, field12)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field12, field13)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field13, field14)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field14, field15)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field15, field16)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field16, field17)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field17, field18)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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 subselect 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.
*
* Unlike {@link Select} factory methods in the {@link DSLContext} API, this
* creates an unattached, and thus not directly renderable or executable
* SELECT statement. You can use this statement in two ways:
*
* - As a subselect within another select
* - As a statement, after attaching it using
* {@link Select#attach(org.jooq.Configuration)}
*
*
* Example:
* import static org.jooq.impl.DSL.*;
*
* // [...]
*
* select(field1, field2, field3, .., field18, field19)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* 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