org.jooq.impl.DSL Maven / Gradle / Ivy
Show all versions of payment-retries-plugin Show documentation
/*
* Copyright (c) 2009-2016, 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.FIREBIRD_3_0;
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.POSTGRES_9_5;
// ...
import static org.jooq.SQLDialect.SQLITE;
// ...
// ...
// ...
// ...
import static org.jooq.impl.Term.ROW_NUMBER;
import static org.jooq.impl.Tools.EMPTY_FIELD;
import static org.jooq.impl.Tools.combine;
import static org.jooq.impl.Tools.configuration;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.OffsetTime;
import java.time.temporal.Temporal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;
import java.util.function.Function;
import javax.annotation.Generated;
import javax.sql.DataSource;
import org.jooq.AggregateFunction;
import org.jooq.AlterIndexStep;
import org.jooq.AlterSchemaStep;
import org.jooq.AlterSequenceStep;
import org.jooq.AlterTableStep;
import org.jooq.AlterViewStep;
import org.jooq.ArrayAggOrderByStep;
// ...
import org.jooq.Case;
import org.jooq.CaseConditionStep;
import org.jooq.CaseValueStep;
import org.jooq.Catalog;
import org.jooq.CommonTableExpression;
import org.jooq.Condition;
import org.jooq.Configuration;
import org.jooq.ConnectionProvider;
import org.jooq.ConstraintFinalStep;
import org.jooq.ConstraintForeignKeyReferencesStep1;
import org.jooq.ConstraintForeignKeyReferencesStep10;
import org.jooq.ConstraintForeignKeyReferencesStep11;
import org.jooq.ConstraintForeignKeyReferencesStep12;
import org.jooq.ConstraintForeignKeyReferencesStep13;
import org.jooq.ConstraintForeignKeyReferencesStep14;
import org.jooq.ConstraintForeignKeyReferencesStep15;
import org.jooq.ConstraintForeignKeyReferencesStep16;
import org.jooq.ConstraintForeignKeyReferencesStep17;
import org.jooq.ConstraintForeignKeyReferencesStep18;
import org.jooq.ConstraintForeignKeyReferencesStep19;
import org.jooq.ConstraintForeignKeyReferencesStep2;
import org.jooq.ConstraintForeignKeyReferencesStep20;
import org.jooq.ConstraintForeignKeyReferencesStep21;
import org.jooq.ConstraintForeignKeyReferencesStep22;
import org.jooq.ConstraintForeignKeyReferencesStep3;
import org.jooq.ConstraintForeignKeyReferencesStep4;
import org.jooq.ConstraintForeignKeyReferencesStep5;
import org.jooq.ConstraintForeignKeyReferencesStep6;
import org.jooq.ConstraintForeignKeyReferencesStep7;
import org.jooq.ConstraintForeignKeyReferencesStep8;
import org.jooq.ConstraintForeignKeyReferencesStep9;
import org.jooq.ConstraintForeignKeyReferencesStepN;
import org.jooq.ConstraintTypeStep;
import org.jooq.CreateIndexStep;
import org.jooq.CreateSchemaFinalStep;
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.DropSchemaStep;
import org.jooq.DropSequenceFinalStep;
import org.jooq.DropTableStep;
import org.jooq.DropViewFinalStep;
import org.jooq.Field;
import org.jooq.FieldOrRow;
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.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.OrderedAggregateFunctionOfDeferredType;
import org.jooq.Param;
import org.jooq.PlainSQL;
import org.jooq.QuantifiedSelect;
import org.jooq.Queries;
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.RecordType;
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.WithAsStep1;
import org.jooq.WithAsStep10;
import org.jooq.WithAsStep11;
import org.jooq.WithAsStep12;
import org.jooq.WithAsStep13;
import org.jooq.WithAsStep14;
import org.jooq.WithAsStep15;
import org.jooq.WithAsStep16;
import org.jooq.WithAsStep17;
import org.jooq.WithAsStep18;
import org.jooq.WithAsStep19;
import org.jooq.WithAsStep2;
import org.jooq.WithAsStep20;
import org.jooq.WithAsStep21;
import org.jooq.WithAsStep22;
import org.jooq.WithAsStep3;
import org.jooq.WithAsStep4;
import org.jooq.WithAsStep5;
import org.jooq.WithAsStep6;
import org.jooq.WithAsStep7;
import org.jooq.WithAsStep8;
import org.jooq.WithAsStep9;
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;
import org.jooq.types.UByte;
import org.jooq.types.UInteger;
import org.jooq.types.ULong;
import org.jooq.types.UShort;
/**
* 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.
*
* Clients must ensure connections are closed properly by calling
* {@link DSLContext#close()} on the resulting {@link DSLContext}. For
* example:
*
*
* // Auto-closing DSLContext instance to free resources
* try (DSLContext ctx = DSL.using("jdbc:h2:~/test")) {
*
* // ...
* }
*
* Clients must ensure connections are closed properly by calling
* {@link DSLContext#close()} on the resulting {@link DSLContext}. For
* example:
*
*
* // Auto-closing DSLContext instance to free resources
* try (DSLContext ctx = DSL.using("jdbc:h2:~/test", "sa", "")) {
*
* // ...
* }
*
* Clients must ensure connections are closed properly by calling
* {@link DSLContext#close()} on the resulting {@link DSLContext}. For
* example:
*
*
* // Auto-closing DSLContext instance to free resources
* try (DSLContext ctx = DSL.using("jdbc:h2:~/test", properties)) {
*
* // ...
* }
*
* 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.
*
* 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.
*
* This works in a similar way as {@link #with(String, String...)}, except
* that all column names are produced by a function that receives the CTE's
* {@link Select} columns as input.
*/
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep with(String alias, Function, ? extends String> fieldNameFunction) {
return new WithImpl(null, false).with(alias, fieldNameFunction);
}
// [jooq-tools] START [with]
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep1 with(String alias, String fieldAlias1) {
return new WithImpl(null, false).with(alias, fieldAlias1);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep2 with(String alias, String fieldAlias1, String fieldAlias2) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep3 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep4 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep5 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep6 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep7 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep8 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep9 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep10 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep11 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep12 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep13 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep14 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep15 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep16 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep17 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep18 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep19 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep20 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep21 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, HSQLDB, POSTGRES })
public static WithAsStep22 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22) {
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
}
// [jooq-tools] END [with]
/**
* 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.
*
* 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.
*
* This works in a similar way as {@link #with(String, String...)}, except
* that all column names are produced by a function that receives the CTE's
* {@link Select} columns as input.
*/
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep withRecursive(String alias, Function, ? extends String> fieldNameFunction) {
return new WithImpl(null, true).with(alias, fieldNameFunction);
}
// [jooq-tools] START [with-recursive]
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep1 withRecursive(String alias, String fieldAlias1) {
return new WithImpl(null, true).with(alias, fieldAlias1);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep2 withRecursive(String alias, String fieldAlias1, String fieldAlias2) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep3 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep4 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep5 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep6 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep7 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep8 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep9 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep10 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep11 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep12 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep13 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep14 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep15 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep16 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep17 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep18 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep19 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep20 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep21 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21);
}
/**
* 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.
*/
@Generated("This method was generated using jOOQ-tools")
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
public static WithAsStep22 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22) {
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
}
// [jooq-tools] END [with-recursive]
/**
* 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(new DefaultConfiguration(), null).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);
*
* Note that passing an empty collection conveniently produces
* SELECT * semantics, i.e. it:
*
* - Renders
SELECT tab1.col1, tab1.col2, ..., tabN.colN if
* all columns are known
* - Renders
SELECT * if not all columns are known, e.g. when
* using plain SQL
*
*
* @see DSLContext#select(Collection)
*/
@Support
public static SelectSelectStep select(Collection> fields) {
return new SelectImpl(new DefaultConfiguration(), null).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);
*
* Note that passing an empty collection conveniently produces
* SELECT * semantics, i.e. it:
*
* - Renders
SELECT tab1.col1, tab1.col2, ..., tabN.colN if
* all columns are known
* - Renders
SELECT * if not all columns are known, e.g. when
* using plain SQL
*
*
* @see DSLContext#select(SelectField...)
*/
@Support
public static SelectSelectStep select(SelectField... fields) {
return new SelectImpl(new DefaultConfiguration(), null).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 field15, SelectField field16, SelectField