org.jooq.impl.DSL Maven / Gradle / Ivy
/**
* Copyright (c) 2009-2015, Data Geekery GmbH (http://www.datageekery.com)
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Other licenses:
* -----------------------------------------------------------------------------
* Commercial licenses for this work are available. These replace the above
* ASL 2.0 and offer limited warranties, support, maintenance, and commercial
* database integrations.
*
* For more information, please visit: http://www.jooq.org/licenses
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package org.jooq.impl;
import static java.util.Arrays.asList;
import static org.jooq.Operator.AND;
import static org.jooq.Operator.OR;
// ...
// ...
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.POSTGRES_9_3;
import static org.jooq.SQLDialect.POSTGRES_9_4;
import static org.jooq.SQLDialect.SQLITE;
// ...
// ...
// ...
import static org.jooq.impl.Term.ROW_NUMBER;
import static org.jooq.impl.Utils.combine;
import static org.jooq.impl.Utils.configuration;
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.ArrayAggOrderByStep;
// ...
import org.jooq.Case;
import org.jooq.CaseConditionStep;
import org.jooq.CaseValueStep;
import org.jooq.CommonTableExpression;
import org.jooq.Condition;
import org.jooq.Configuration;
import org.jooq.ConnectionProvider;
import org.jooq.ConstraintTypeStep;
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.DropIndexOnStep;
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.Operator;
import org.jooq.OrderedAggregateFunction;
import org.jooq.Param;
import org.jooq.PlainSQL;
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.SQL;
import org.jooq.SQLDialect;
import org.jooq.Schema;
import org.jooq.Select;
import org.jooq.SelectField;
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(SelectField... 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(SelectField field1) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8, SelectField field9) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8, SelectField field9, SelectField field10) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8, SelectField field9, SelectField field10, SelectField field11) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8, SelectField field9, SelectField field10, SelectField field11, SelectField field12) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8, SelectField field9, SelectField field10, SelectField field11, SelectField field12, SelectField field13) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8, SelectField field9, SelectField field10, SelectField field11, SelectField field12, SelectField field13, SelectField field14) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8, SelectField field9, SelectField field10, SelectField field11, SelectField field12, SelectField field13, SelectField field14, SelectField field15) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8, SelectField field9, SelectField field10, SelectField field11, SelectField field12, SelectField field13, SelectField field14, SelectField field15, SelectField field16) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8, SelectField field9, SelectField field10, SelectField field11, SelectField field12, SelectField field13, SelectField field14, SelectField field15, SelectField field16, SelectField field17) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8, SelectField field9, SelectField field10, SelectField field11, SelectField field12, SelectField field13, SelectField field14, SelectField field15, SelectField field16, SelectField field17, SelectField field18) {
return (SelectSelectStep) select(new SelectField[] { 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(SelectField field1, SelectField field2, SelectField field3, SelectField field4, SelectField field5, SelectField field6, SelectField field7, SelectField field8, SelectField field9, SelectField field10, SelectField field11, SelectField field12, SelectField field13, SelectField field14, SelectField