primaryKey
PRIMARY KEY constraint.AccessDSL, ASEDSL, CUBRIDDSL, DB2DSL, DerbyDSL, FirebirdDSL, H2DSL, HanaDSL, HSQLDBDSL, InformixDSL, IngresDSL, MariaDBDSL, MySQLDSL, OracleDSL, PostgresDSL, RedshiftDSL, SQLiteDSL, SQLServerDSL, SybaseDSL, VerticaDSLorg.jooq
interfaces.
The 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 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 Condition:
Condition condition = DSL.exists(DSL.select(...));
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
using(Configuration) methods:
// Create and immediately execute a SELECT statement:
DSL.using(connection, dialect)
.selectOne()
.fetch();
ABS function.abs(T value) ABS function.static @NotNull Field<BigDecimal>ACOS function.static @NotNull Field<BigDecimal>ACOS function.static @NotNull Field<BigDecimal>ACOSH function.static @NotNull Field<BigDecimal>ACOSH function.static @NotNull Field<BigDecimal>ACOTH function.static @NotNull Field<BigDecimal>ACOTH function.static <T> @NotNull AggregateFunction<T>aggregate() can be used to access native or user-defined
aggregate functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull AggregateFunction<T>aggregate() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.static <T> @NotNull AggregateFunction<T>aggregate() can be used to access native or user-defined
aggregate functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull AggregateFunction<T>aggregate() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.static <T> @NotNull AggregateFunction<T>aggregateDistinct(String name,
Class<T> type,
Field<?>... arguments) aggregateDistinct() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.static <T> @NotNull AggregateFunction<T>aggregateDistinct(String name,
DataType<T> type,
Field<?>... arguments) aggregateDistinct() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.static <T> @NotNull AggregateFunction<T>aggregateDistinct(Name name,
Class<T> type,
Field<?>... arguments) aggregateDistinct() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.static <T> @NotNull AggregateFunction<T>aggregateDistinct(Name name,
DataType<T> type,
Field<?>... arguments) aggregateDistinct() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.static <T> @NotNull QuantifiedSelect<Record1<T>>ALL quantified select to be used in quantified
comparison predicate expressions.static <T> @NotNull QuantifiedSelect<Record1<T>>ALL quantified select to be used in quantified
comparison predicate expressions.static <R extends Record>
@NotNull QuantifiedSelect<R>ALL quantified select to be used in quantified
comparison predicate expressions.static <T> @NotNull QuantifiedSelect<Record1<T>>all(T... array) ALL quantified select to be used in quantified
comparison predicate expressions.static AlterDatabaseStepalterDatabase(String database) ALTER DATABASE statement.static AlterDatabaseStepalterDatabase(Catalog database) ALTER DATABASE statement.static AlterDatabaseStepalterDatabase(Name database) ALTER DATABASE statement.static AlterDatabaseStepalterDatabaseIfExists(String database) ALTER DATABASE IF EXISTS statement.static AlterDatabaseStepalterDatabaseIfExists(Catalog database) ALTER DATABASE IF EXISTS statement.static AlterDatabaseStepalterDatabaseIfExists(Name database) ALTER DATABASE IF EXISTS statement.static <T> AlterDomainStep<T>alterDomain(String domain) ALTER DOMAIN statement.static <T> AlterDomainStep<T>alterDomain(Domain<T> domain) ALTER DOMAIN statement.static <T> AlterDomainStep<T>alterDomain(Name domain) ALTER DOMAIN statement.static <T> AlterDomainStep<T>alterDomainIfExists(String domain) ALTER DOMAIN IF EXISTS statement.static <T> AlterDomainStep<T>alterDomainIfExists(Domain<T> domain) ALTER DOMAIN IF EXISTS statement.static <T> AlterDomainStep<T>alterDomainIfExists(Name domain) ALTER DOMAIN IF EXISTS statement.static AlterIndexOnStepalterIndex(String index) ALTER INDEX statement.static AlterIndexOnStepalterIndex(Index index) ALTER INDEX statement.static AlterIndexOnStepalterIndex(Name index) ALTER INDEX statement.static AlterIndexOnStepalterIndexIfExists(String index) ALTER INDEX IF EXISTS statement.static AlterIndexOnStepalterIndexIfExists(Index index) ALTER INDEX IF EXISTS statement.static AlterIndexOnStepalterIndexIfExists(Name index) ALTER INDEX IF EXISTS statement.static AlterViewStepalterMaterializedView(String view) ALTER MATERIALIZED VIEW statement.static AlterViewStepalterMaterializedView(Name view) ALTER MATERIALIZED VIEW statement.static AlterViewStepalterMaterializedView(Table<?> view) ALTER MATERIALIZED VIEW statement.static AlterViewStepALTER MATERIALIZED VIEW IF EXISTS statement.static AlterViewStepALTER MATERIALIZED VIEW IF EXISTS statement.static AlterViewStepalterMaterializedViewIfExists(Table<?> view) ALTER MATERIALIZED VIEW IF EXISTS statement.static AlterSchemaStepalterSchema(String schema) ALTER SCHEMA statement.static AlterSchemaStepalterSchema(Name schema) ALTER SCHEMA statement.static AlterSchemaStepalterSchema(Schema schema) ALTER SCHEMA statement.static AlterSchemaStepalterSchemaIfExists(String schema) ALTER SCHEMA IF EXISTS statement.static AlterSchemaStepalterSchemaIfExists(Name schema) ALTER SCHEMA IF EXISTS statement.static AlterSchemaStepalterSchemaIfExists(Schema schema) ALTER SCHEMA IF EXISTS statement.static AlterSequenceStep<Number>alterSequence(String sequence) ALTER SEQUENCE statement.static AlterSequenceStep<Number>alterSequence(Name sequence) ALTER SEQUENCE statement.static <T extends Number>
AlterSequenceStep<T>alterSequence(Sequence<T> sequence) ALTER SEQUENCE statement.static AlterSequenceStep<Number>alterSequenceIfExists(String sequence) ALTER SEQUENCE IF EXISTS statement.static AlterSequenceStep<Number>alterSequenceIfExists(Name sequence) ALTER SEQUENCE IF EXISTS statement.static <T extends Number>
AlterSequenceStep<T>alterSequenceIfExists(Sequence<T> sequence) ALTER SEQUENCE IF EXISTS statement.static @NotNull AlterTableStepalterTable(String table) ALTER TABLE statement.static @NotNull AlterTableStepalterTable(Name table) ALTER TABLE statement.static @NotNull AlterTableStepalterTable(Table<?> table) ALTER TABLE statement.static @NotNull AlterTableStepalterTableIfExists(String table) ALTER TABLE statement.static @NotNull AlterTableStepalterTableIfExists(Name table) ALTER TABLE statement.static @NotNull AlterTableStepalterTableIfExists(Table<?> table) ALTER TABLE statement.static AlterTypeStepALTER TYPE statement.static AlterTypeStepALTER TYPE statement.static AlterTypeStepalterTypeIfExists(String type) ALTER TYPE IF EXISTS statement.static AlterTypeStepalterTypeIfExists(Name type) ALTER TYPE IF EXISTS statement.static AlterViewStepALTER VIEW statement.static AlterViewStepALTER VIEW statement.static AlterViewStepALTER VIEW statement.static AlterViewStepalterView(Table<?> view,
Collection<? extends Field<?>> fields) ALTER VIEW statement.static AlterViewStepALTER VIEW statement.static AlterViewStepalterViewIfExists(String view) ALTER VIEW IF EXISTS statement.static AlterViewStepalterViewIfExists(Name view) ALTER VIEW IF EXISTS statement.static AlterViewStepalterViewIfExists(Table<?> view) ALTER VIEW IF EXISTS statement.static @NotNull Conditionand(Collection<? extends Condition> conditions) static @NotNull Conditionstatic @NotNull Conditionstatic <T> @NotNull QuantifiedSelect<Record1<T>>ANY quantified select to be used in quantified
comparison predicate expressions.static <T> @NotNull QuantifiedSelect<Record1<T>>ANY quantified select to be used in quantified
comparison predicate expressions.static <R extends Record>
@NotNull QuantifiedSelect<R>ANY quantified select to be used in quantified
comparison predicate expressions.static <T> @NotNull QuantifiedSelect<Record1<T>>any(T... array) ANY quantified select to be used in quantified
comparison predicate expressions.static <T> @NotNull AggregateFunction<T>ANY_VALUE function.static <T> @NotNull Field<T[]>array(Collection<? extends Field<T>> fields) static <T> @NotNull Field<T[]>static <T> @NotNull Field<T[]>array(select) function.static <T> @NotNull Field<T[]>array(T... values) static <T> @NotNull ArrayAggOrderByStep<T[]>array_agg() aggregate function.static <T> @NotNull ArrayAggOrderByStep<T[]>arrayAggDistinct(Field<T> field) array_agg() aggregate function.static <T> @NotNull Field<T[]>arrayAppend(Field<T[]> arg1,
Field<T> arg2) ARRAY_APPEND function.static <T> @NotNull Field<T[]>arrayAppend(Field<T[]> arg1,
T arg2) ARRAY_APPEND function.static <T> @NotNull Field<T[]>arrayAppend(T[] arg1,
Field<T> arg2) ARRAY_APPEND function.static <T> @NotNull Field<T[]>arrayAppend(T[] arg1,
T arg2) ARRAY_APPEND function.static <T> @NotNull Field<T[]>arrayConcat(Field<T[]> arg1,
Field<T[]> arg2) ARRAY_CONCAT function.static <T> @NotNull Field<T[]>arrayConcat(Field<T[]> arg1,
T[] arg2) ARRAY_CONCAT function.static <T> @NotNull Field<T[]>arrayConcat(T[] arg1,
Field<T[]> arg2) ARRAY_CONCAT function.static <T> @NotNull Field<T[]>arrayConcat(T[] arg1,
T[] arg2) ARRAY_CONCAT function.static <T> @NotNull Field<T>ARRAY_GET function.static <T> @NotNull Field<T>ARRAY_GET function.static <T> @NotNull ConditionarrayOverlap(Field<T[]> arg1,
Field<T[]> arg2) ARRAY_OVERLAP function.static <T> @NotNull ConditionarrayOverlap(Field<T[]> arg1,
T[] arg2) ARRAY_OVERLAP function.static <T> @NotNull ConditionarrayOverlap(T[] arg1,
Field<T[]> arg2) ARRAY_OVERLAP function.static <T> @NotNull ConditionarrayOverlap(T[] arg1,
T[] arg2) ARRAY_OVERLAP function.static <T> @NotNull Field<T[]>arrayPrepend(Field<T> arg1,
Field<T[]> arg2) ARRAY_PREPEND function.static <T> @NotNull Field<T[]>arrayPrepend(Field<T> arg1,
T[] arg2) ARRAY_PREPEND function.static <T> @NotNull Field<T[]>arrayPrepend(T arg1,
Field<T[]> arg2) ARRAY_PREPEND function.static <T> @NotNull Field<T[]>arrayPrepend(T arg1,
T[] arg2) ARRAY_PREPEND function.static <T> @NotNull Field<T[]>arrayRemove(Field<T[]> arg1,
Field<T> arg2) ARRAY_REMOVE function.static <T> @NotNull Field<T[]>arrayRemove(Field<T[]> arg1,
T arg2) ARRAY_REMOVE function.static <T> @NotNull Field<T[]>arrayRemove(T[] arg1,
Field<T> arg2) ARRAY_REMOVE function.static <T> @NotNull Field<T[]>arrayRemove(T[] arg1,
T arg2) ARRAY_REMOVE function.static <T> @NotNull Field<T[]>arrayReplace(Field<T[]> arg1,
Field<T> arg2,
Field<T> arg3) ARRAY_REPLACE function.static <T> @NotNull Field<T[]>arrayReplace(T[] arg1,
T arg2,
T arg3) ARRAY_REPLACE function.ASCII function.ASCII function.static @NotNull Field<BigDecimal>ASIN function.static @NotNull Field<BigDecimal>ASIN function.static @NotNull Field<BigDecimal>ASINH function.static @NotNull Field<BigDecimal>ASINH function.static @NotNull Asteriskasterisk()*) to be used in SELECT clauses.static @NotNull Field<BigDecimal>ATAN function.static @NotNull Field<BigDecimal>ATAN function.static @NotNull Field<BigDecimal>ATAN2 function.static @NotNull Field<BigDecimal>ATAN2 function.static @NotNull Field<BigDecimal>ATAN2 function.static @NotNull Field<BigDecimal>ATAN2 function.static @NotNull Field<BigDecimal>ATANH function.static @NotNull Field<BigDecimal>ATANH function.static @NotNull AggregateFunction<BigDecimal>AVG function.static @NotNull AggregateFunction<BigDecimal>avgDistinct(Field<? extends Number> field) AVG_DISTINCT function.static @NotNull Blockbegin(Collection<? extends Statement> statements) static @NotNull BlockBIT_AND function.BIT_AND function.BIT_AND function.bitAnd(T arg1,
T arg2) BIT_AND function.static <T extends Number>
@NotNull AggregateFunction<T>BIT_AND_AGG function.BIT_COUNT function.BIT_COUNT function.BIT_GET function.BIT_GET function.BIT_LENGTH function.BIT_LENGTH function.BIT_NAND function.BIT_NAND function.BIT_NAND function.bitNand(T arg1,
T arg2) BIT_NAND function.static <T extends Number>
@NotNull AggregateFunction<T>bitNandAgg(Field<T> value) BIT_NAND_AGG function.BIT_NOR function.BIT_NOR function.BIT_NOR function.bitNor(T arg1,
T arg2) BIT_NOR function.static <T extends Number>
@NotNull AggregateFunction<T>BIT_NOR_AGG function.BIT_NOT function.bitNot(T arg1) BIT_NOT function.BIT_OR function.BIT_OR function.BIT_OR function.bitOr(T arg1,
T arg2) BIT_OR function.static <T extends Number>
@NotNull AggregateFunction<T>BIT_OR_AGG function.BIT_SET function.BIT_SET function.BIT_SET function.BIT_SET function.BIT_SET function.BIT_SET function.BIT_XNOR function.BIT_XNOR function.BIT_XNOR function.bitXNor(T arg1,
T arg2) BIT_XNOR function.static <T extends Number>
@NotNull AggregateFunction<T>bitXNorAgg(Field<T> value) BIT_XNOR_AGG function.BIT_XOR function.BIT_XOR function.BIT_XOR function.bitXor(T arg1,
T arg2) BIT_XOR function.static <T extends Number>
@NotNull AggregateFunction<T>BIT_XOR_AGG function.static @NotNull AggregateFunction<Boolean>BOOL_AND function.static @NotNull AggregateFunction<Boolean>BOOL_AND function.static @NotNull AggregateFunction<Boolean>BOOL_OR function.static @NotNull AggregateFunction<Boolean>BOOL_OR function.static CallArgsStepCALL statement.static CallArgsStepCALL statement.cardinality(Field<? extends Object[]> array) CARDINALITY function.static @NotNull Casecase_()Case statement.static <V> @NotNull CaseValueStep<V>Case statement.static <V> @NotNull CaseValueStep<V>case_(V value) Case statement.static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static @NotNull Catalogstatic @NotNull CatalogCEIL function.ceil(T value) CEIL function.static @NotNull CharacterSetcharacterSet(String characterSet) static @NotNull CharacterSetcharacterSet(Name characterSet) charLength(String string) CHAR_LENGTH function.charLength(Field<String> string) CHAR_LENGTH function.static @NotNull ConstraintEnforcementStepCHECK constraint.static @NotNull Casechoose()Case statement.static <T> @NotNull Field<T>CHOOSE() function.static <T> @NotNull Field<T>choose(int index,
T... values) CHOOSE() function.static <T> @NotNull Field<T>CHOOSE() function.static <T> @NotNull Field<T>CHOOSE() function.static <V> @NotNull CaseValueStep<V>Case statement.static <V> @NotNull CaseValueStep<V>choose(V value) Case statement.CHR function.CHR function.static <T> @NotNull Field<T>COALESCE(field1, field2, … , field n) function.static <T> @NotNull Field<T>COALESCE(field, value) function.static <T> @NotNull Field<T>coalesce(T value,
T... values) COALESCE(value1, value2, … , value n) function.static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static @NotNull Collationstatic @NotNull Collationstatic <T,
A extends ArrayRecord<T>>
@NotNull ArrayAggOrderByStep<A> collect() aggregate function.static <T,
A extends ArrayRecord<T>>
@NotNull ArrayAggOrderByStep<A> collect() aggregate function.static <T,
A extends ArrayRecord<T>>
@NotNull ArrayAggOrderByStep<A> collectDistinct(Field<T> field,
Class<A> type) collect() aggregate function.static <T,
A extends ArrayRecord<T>>
@NotNull ArrayAggOrderByStep<A> collectDistinct(Field<T> field,
DataType<A> type) collect() aggregate function.static @NotNull Commentstatic CommentOnIsStepcommentOnColumn(String field) COMMENT ON COLUMN statement.static CommentOnIsStepcommentOnColumn(Field<?> field) COMMENT ON COLUMN statement.static CommentOnIsStepcommentOnColumn(Name field) COMMENT ON COLUMN statement.static CommentOnIsStepCOMMENT ON MATERIALIZED VIEW statement.static CommentOnIsStepCOMMENT ON MATERIALIZED VIEW statement.static CommentOnIsStepcommentOnMaterializedView(Table<?> view) COMMENT ON MATERIALIZED VIEW statement.static CommentOnIsStepcommentOnTable(String table) COMMENT ON TABLE statement.static CommentOnIsStepcommentOnTable(Name table) COMMENT ON TABLE statement.static CommentOnIsStepcommentOnTable(Table<?> table) COMMENT ON TABLE statement.static CommentOnIsStepcommentOnView(String view) COMMENT ON VIEW statement.static CommentOnIsStepcommentOnView(Name view) COMMENT ON VIEW statement.static CommentOnIsStepcommentOnView(Table<?> view) COMMENT ON VIEW statement.static Querycommit()COMMIT statement.concat(value, field) function.concat(field, value) function.static @NotNull Conditionstatic @NotNull Conditionstatic @NotNull Conditionstatic @NotNull Conditionstatic @NotNull Conditionstatic @NotNull ConditionCONDITION function.static @NotNull Conditioncondition(Operator operator,
Collection<? extends Condition> conditions) Condition that connects all argument
conditions with Operator.static @NotNull ConditionCondition that connects all argument
conditions with Operator.static @NotNull ConditionCondition that connects all argument
conditions with Operator.static @NotNull Conditionstatic @NotNull ConditionCONNECT_BY_ISCYCLE function.CONNECT_BY_ISLEAF function.static <T> @NotNull Field<T>connectByRoot(Field<T> field) CONNECT_BY_ROOT function.static @NotNull ConstraintTypeStepCONSTRAINT specification.static @NotNull ConstraintTypeStepconstraint(String name) CONSTRAINT specification.static @NotNull ConstraintTypeStepconstraint(Name name) CONSTRAINT specification.static @NotNull ContinueWhenStepCONTINUE statement for use in procedural code.static @NotNull ContinueWhenStepCONTINUE statement for use in procedural code.static @NotNull StatementcontinueWhen(Condition condition) CONTINUE statement for use in procedural code.static @NotNull StatementcontinueWhen(Field<Boolean> condition) CONTINUE statement for use in procedural code.static <T> @NotNull Field<T>CONVERT() function.static <T> @NotNull Field<T>CONVERT() function.static @NotNull AggregateFunction<BigDecimal>CORR function.static @NotNull Field<BigDecimal>COS function.static @NotNull Field<BigDecimal>COS function.static @NotNull Field<BigDecimal>COSH function.static @NotNull Field<BigDecimal>COSH function.static @NotNull Field<BigDecimal>COT function.static @NotNull Field<BigDecimal>COT function.static @NotNull Field<BigDecimal>COTH function.static @NotNull Field<BigDecimal>COTH function.static @NotNull AggregateFunction<Integer>count()static @NotNull AggregateFunction<Integer>COUNT function.static @NotNull AggregateFunction<Integer>count(SelectFieldOrAsterisk field) static @NotNull AggregateFunction<Integer>static @NotNull AggregateFunction<Integer>countDistinct(Field<?> field) COUNT_DISTINCT function.static @NotNull AggregateFunction<Integer>countDistinct(Field<?>... fields) static @NotNull AggregateFunction<Integer>static @NotNull AggregateFunction<Integer>countDistinct(Table<?> table) static @NotNull AggregateFunction<BigDecimal>COVAR_POP function.static @NotNull AggregateFunction<BigDecimal>COVAR_SAMP function.static CreateDatabaseFinalStepcreateDatabase(String database) CREATE DATABASE statement.static CreateDatabaseFinalStepcreateDatabase(Catalog database) CREATE DATABASE statement.static CreateDatabaseFinalStepcreateDatabase(Name database) CREATE DATABASE statement.static CreateDatabaseFinalStepcreateDatabaseIfNotExists(String database) CREATE DATABASE IF NOT EXISTS statement.static CreateDatabaseFinalStepcreateDatabaseIfNotExists(Catalog database) CREATE DATABASE IF NOT EXISTS statement.static CreateDatabaseFinalStepcreateDatabaseIfNotExists(Name database) CREATE DATABASE IF NOT EXISTS statement.static CreateDomainAsStepcreateDomain(String domain) CREATE DOMAIN statement.static CreateDomainAsStepcreateDomain(Domain<?> domain) CREATE DOMAIN statement.static CreateDomainAsStepcreateDomain(Name domain) CREATE DOMAIN statement.static CreateDomainAsStepcreateDomainIfNotExists(String domain) CREATE DOMAIN IF NOT EXISTS statement.static CreateDomainAsStepcreateDomainIfNotExists(Domain<?> domain) CREATE DOMAIN IF NOT EXISTS statement.static CreateDomainAsStepcreateDomainIfNotExists(Name domain) CREATE DOMAIN IF NOT EXISTS statement.static CreateFunctionParametersStepcreateFunction(String function) CREATE FUNCTION statement.static CreateFunctionParametersStepcreateFunction(Name function) CREATE FUNCTION statement.static CreateTableElementListStepcreateGlobalTemporaryTable(String table) CREATE GLOBAL TEMPORARY TABLE statement.static CreateTableElementListStepcreateGlobalTemporaryTable(Name table) CREATE GLOBAL TEMPORARY TABLE statement.static CreateTableElementListStepcreateGlobalTemporaryTable(Table<?> table) CREATE GLOBAL TEMPORARY TABLE statement.static CreateTableElementListStepCREATE GLOBAL TEMPORARY TABLE IF NOT EXISTS statement.static CreateTableElementListStepCREATE GLOBAL TEMPORARY TABLE IF NOT EXISTS statement.static CreateTableElementListStepcreateGlobalTemporaryTableIfNotExists(Table<?> table) CREATE GLOBAL TEMPORARY TABLE IF NOT EXISTS statement.static CreateIndexStepCREATE INDEX statement.static CreateIndexStepcreateIndex(String index) CREATE INDEX statement.static CreateIndexStepcreateIndex(Index index) CREATE INDEX statement.static CreateIndexStepcreateIndex(Name index) CREATE INDEX statement.static CreateIndexStepCREATE INDEX IF NOT EXISTS statement.static CreateIndexStepcreateIndexIfNotExists(String index) CREATE INDEX IF NOT EXISTS statement.static CreateIndexStepcreateIndexIfNotExists(Index index) CREATE INDEX IF NOT EXISTS statement.static CreateIndexStepcreateIndexIfNotExists(Name index) CREATE INDEX IF NOT EXISTS statement.static CreateViewAsStep<Record>createMaterializedView(String view,
String... fields) CREATE MATERIALIZED VIEW statement.static CreateViewAsStep<Record>createMaterializedView(String view,
Collection<? extends String> fields) CREATE MATERIALIZED VIEW statement.static CreateViewAsStep<Record>createMaterializedView(Name view,
Collection<? extends Name> fields) CREATE MATERIALIZED VIEW statement.static CreateViewAsStep<Record>createMaterializedView(Name view,
Name... fields) CREATE MATERIALIZED VIEW statement.static CreateViewAsStep<Record>createMaterializedView(Table<?> view,
Collection<? extends Field<?>> fields) CREATE MATERIALIZED VIEW statement.static CreateViewAsStep<Record>createMaterializedView(Table<?> view,
Field<?>... fields) CREATE MATERIALIZED VIEW statement.static CreateViewAsStep<Record>createMaterializedViewIfNotExists(String view,
String... fields) CREATE MATERIALIZED VIEW IF NOT EXISTS statement.static CreateViewAsStep<Record>createMaterializedViewIfNotExists(String view,
Collection<? extends String> fields) CREATE MATERIALIZED VIEW IF NOT EXISTS statement.static CreateViewAsStep<Record>createMaterializedViewIfNotExists(Name view,
Collection<? extends Name> fields) CREATE MATERIALIZED VIEW IF NOT EXISTS statement.static CreateViewAsStep<Record>createMaterializedViewIfNotExists(Name view,
Name... fields) CREATE MATERIALIZED VIEW IF NOT EXISTS statement.static CreateViewAsStep<Record>createMaterializedViewIfNotExists(Table<?> view,
Collection<? extends Field<?>> fields) CREATE MATERIALIZED VIEW IF NOT EXISTS statement.static CreateViewAsStep<Record>createMaterializedViewIfNotExists(Table<?> view,
Field<?>... fields) CREATE MATERIALIZED VIEW IF NOT EXISTS statement.static CreateFunctionParametersStepcreateOrReplaceFunction(String function) CREATE OR REPLACE FUNCTION statement.static CreateFunctionParametersStepcreateOrReplaceFunction(Name function) CREATE OR REPLACE FUNCTION statement.static CreateViewAsStep<Record>createOrReplaceMaterializedView(String view,
String... fields) CREATE OR REPLACE MATERIALIZED VIEW statement.static CreateViewAsStep<Record>createOrReplaceMaterializedView(String view,
Collection<? extends String> fields) CREATE OR REPLACE MATERIALIZED VIEW statement.static CreateViewAsStep<Record>createOrReplaceMaterializedView(Name view,
Collection<? extends Name> fields) CREATE OR REPLACE MATERIALIZED VIEW statement.static CreateViewAsStep<Record>createOrReplaceMaterializedView(Name view,
Name... fields) CREATE OR REPLACE MATERIALIZED VIEW statement.static CreateViewAsStep<Record>createOrReplaceMaterializedView(Table<?> view,
Collection<? extends Field<?>> fields) CREATE OR REPLACE MATERIALIZED VIEW statement.static CreateViewAsStep<Record>createOrReplaceMaterializedView(Table<?> view,
Field<?>... fields) CREATE OR REPLACE MATERIALIZED VIEW statement.createOrReplaceProcedure(String procedure) CREATE OR REPLACE PROCEDURE statement.createOrReplaceProcedure(Name procedure) CREATE OR REPLACE PROCEDURE statement.static CreateTriggerEventStepcreateOrReplaceTrigger(String trigger) CREATE OR REPLACE TRIGGER statement.static CreateTriggerEventStepcreateOrReplaceTrigger(Name trigger) CREATE OR REPLACE TRIGGER statement.static CreateTriggerEventStepcreateOrReplaceTrigger(Trigger trigger) CREATE OR REPLACE TRIGGER statement.static CreateViewAsStep<Record>createOrReplaceView(String view,
String... fields) CREATE OR REPLACE VIEW statement.static CreateViewAsStep<Record>createOrReplaceView(String view,
Collection<? extends String> fields) CREATE OR REPLACE VIEW statement.static @NotNull CreateViewAsStep<Record>createOrReplaceView(String view,
Function<? super Field<?>,? extends String> fieldNameFunction) static CreateViewAsStep<Record>createOrReplaceView(Name view,
Collection<? extends Name> fields) CREATE OR REPLACE VIEW statement.static @NotNull CreateViewAsStep<Record>createOrReplaceView(Name view,
Function<? super Field<?>,? extends Name> fieldNameFunction) static CreateViewAsStep<Record>createOrReplaceView(Name view,
Name... fields) CREATE OR REPLACE VIEW statement.static CreateViewAsStep<Record>createOrReplaceView(Table<?> view,
Collection<? extends Field<?>> fields) CREATE OR REPLACE VIEW statement.static @NotNull CreateViewAsStep<Record>createOrReplaceView(Table<?> view,
Function<? super Field<?>,? extends Field<?>> fieldNameFunction) static CreateViewAsStep<Record>createOrReplaceView(Table<?> view,
Field<?>... fields) CREATE OR REPLACE VIEW statement.createProcedure(String procedure) CREATE PROCEDURE statement.createProcedure(Name procedure) CREATE PROCEDURE statement.static CreateSchemaFinalStepcreateSchema(String schema) CREATE SCHEMA statement.static CreateSchemaFinalStepcreateSchema(Name schema) CREATE SCHEMA statement.static CreateSchemaFinalStepcreateSchema(Schema schema) CREATE SCHEMA statement.static CreateSchemaFinalStepcreateSchemaIfNotExists(String schema) CREATE SCHEMA IF NOT EXISTS statement.static CreateSchemaFinalStepcreateSchemaIfNotExists(Name schema) CREATE SCHEMA IF NOT EXISTS statement.static CreateSchemaFinalStepcreateSchemaIfNotExists(Schema schema) CREATE SCHEMA IF NOT EXISTS statement.static CreateSequenceFlagsStepcreateSequence(String sequence) CREATE SEQUENCE statement.static CreateSequenceFlagsStepcreateSequence(Name sequence) CREATE SEQUENCE statement.static CreateSequenceFlagsStepcreateSequence(Sequence<?> sequence) CREATE SEQUENCE statement.static CreateSequenceFlagsStepcreateSequenceIfNotExists(String sequence) CREATE SEQUENCE IF NOT EXISTS statement.static CreateSequenceFlagsStepcreateSequenceIfNotExists(Name sequence) CREATE SEQUENCE IF NOT EXISTS statement.static CreateSequenceFlagsStepcreateSequenceIfNotExists(Sequence<?> sequence) CREATE SEQUENCE IF NOT EXISTS statement.static CreateTableElementListStepcreateTable(String table) CREATE TABLE statement.static CreateTableElementListStepcreateTable(Name table) CREATE TABLE statement.static CreateTableElementListStepcreateTable(Table<?> table) CREATE TABLE statement.static CreateTableElementListStepcreateTableIfNotExists(String table) CREATE TABLE IF NOT EXISTS statement.static CreateTableElementListStepcreateTableIfNotExists(Name table) CREATE TABLE IF NOT EXISTS statement.static CreateTableElementListStepcreateTableIfNotExists(Table<?> table) CREATE TABLE IF NOT EXISTS statement.static CreateTableElementListStepcreateTemporaryTable(String table) CREATE TEMPORARY TABLE statement.static CreateTableElementListStepcreateTemporaryTable(Name table) CREATE TEMPORARY TABLE statement.static CreateTableElementListStepcreateTemporaryTable(Table<?> table) CREATE TEMPORARY TABLE statement.static CreateTableElementListStepCREATE TEMPORARY TABLE IF NOT EXISTS statement.static CreateTableElementListStepCREATE TEMPORARY TABLE IF NOT EXISTS statement.static CreateTableElementListStepcreateTemporaryTableIfNotExists(Table<?> table) CREATE TEMPORARY TABLE IF NOT EXISTS statement.static CreateTriggerEventStepcreateTrigger(String trigger) CREATE TRIGGER statement.static CreateTriggerEventStepcreateTrigger(Name trigger) CREATE TRIGGER statement.static CreateTriggerEventStepcreateTrigger(Trigger trigger) CREATE TRIGGER statement.static CreateTypeStepcreateType(String type) CREATE TYPE statement.static CreateTypeStepcreateType(Name type) CREATE TYPE statement.static CreateTypeStepcreateType(Type<?> type) CREATE TYPE statement.static CreateTypeStepcreateTypeIfNotExists(String type) CREATE TYPE IF NOT EXISTS statement.static CreateTypeStepcreateTypeIfNotExists(Name type) CREATE TYPE IF NOT EXISTS statement.static CreateTypeStepcreateTypeIfNotExists(Type<?> type) CREATE TYPE IF NOT EXISTS statement.static CreateIndexStepCREATE UNIQUE INDEX statement.static CreateIndexStepcreateUniqueIndex(String index) CREATE UNIQUE INDEX statement.static CreateIndexStepcreateUniqueIndex(Index index) CREATE UNIQUE INDEX statement.static CreateIndexStepcreateUniqueIndex(Name index) CREATE UNIQUE INDEX statement.static CreateIndexStepCREATE UNIQUE INDEX IF NOT EXISTS statement.static CreateIndexStepCREATE UNIQUE INDEX IF NOT EXISTS statement.static CreateIndexStepCREATE UNIQUE INDEX IF NOT EXISTS statement.static CreateIndexStepcreateUniqueIndexIfNotExists(Name index) CREATE UNIQUE INDEX IF NOT EXISTS statement.static CreateViewAsStep<Record>createView(String view,
String... fields) CREATE VIEW statement.static CreateViewAsStep<Record>createView(String view,
Collection<? extends String> fields) CREATE VIEW statement.static @NotNull CreateViewAsStep<Record>createView(String view,
Function<? super Field<?>,? extends String> fieldNameFunction) static CreateViewAsStep<Record>createView(Name view,
Collection<? extends Name> fields) CREATE VIEW statement.static @NotNull CreateViewAsStep<Record>createView(Name view,
Function<? super Field<?>,? extends Name> fieldNameFunction) static CreateViewAsStep<Record>createView(Name view,
Name... fields) CREATE VIEW statement.static CreateViewAsStep<Record>createView(Table<?> view,
Collection<? extends Field<?>> fields) CREATE VIEW statement.static @NotNull CreateViewAsStep<Record>createView(Table<?> view,
Function<? super Field<?>,? extends Field<?>> fieldNameFunction) static CreateViewAsStep<Record>createView(Table<?> view,
Field<?>... fields) CREATE VIEW statement.static CreateViewAsStep<Record>createViewIfNotExists(String view,
String... fields) CREATE VIEW IF NOT EXISTS statement.static CreateViewAsStep<Record>createViewIfNotExists(String view,
Collection<? extends String> fields) CREATE VIEW IF NOT EXISTS statement.static @NotNull CreateViewAsStep<Record>createViewIfNotExists(String view,
Function<? super Field<?>,? extends String> fieldNameFunction) static CreateViewAsStep<Record>createViewIfNotExists(Name view,
Collection<? extends Name> fields) CREATE VIEW IF NOT EXISTS statement.static @NotNull CreateViewAsStep<Record>createViewIfNotExists(Name view,
Function<? super Field<?>,? extends Name> fieldNameFunction) static CreateViewAsStep<Record>createViewIfNotExists(Name view,
Name... fields) CREATE VIEW IF NOT EXISTS statement.static CreateViewAsStep<Record>createViewIfNotExists(Table<?> view,
Collection<? extends Field<?>> fields) CREATE VIEW IF NOT EXISTS statement.static @NotNull CreateViewAsStep<Record>createViewIfNotExists(Table<?> view,
Function<? super Field<?>,? extends Field<?>> fieldNameFunction) static CreateViewAsStep<Record>createViewIfNotExists(Table<?> view,
Field<?>... fields) CREATE VIEW IF NOT EXISTS statement.static @NotNull GroupFieldstatic @NotNull GroupFieldcube(FieldOrRow... fields) static @NotNull WindowOverStep<BigDecimal>cumeDist()cume_dist() over ([analytic clause]) function.static @NotNull OrderedAggregateFunction<BigDecimal>cumeDist(Collection<? extends Field<?>> fields) cume_dist(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<BigDecimal>cume_dist(expr) within group (order by [order clause])
ordered-set aggregate function.CURRENT_CATALOG function.SQLDataType.DATE type.SQLDataType.DATE type.static @NotNull Field<LocalDateTime>SQLDataType.TIMESTAMP type.static @NotNull Field<LocalDateTime>currentLocalDateTime(int precision) SQLDataType.TIMESTAMP type with the specified fractional
seconds precision.static @NotNull Field<LocalDateTime>currentLocalDateTime(Field<Integer> precision) SQLDataType.TIMESTAMP type with the specified fractional
seconds precision.SQLDataType.TIME type.static @NotNull Field<OffsetDateTime>static @NotNull Field<OffsetTime>CURRENT_SCHEMA function.SQLDataType.TIME type.SQLDataType.TIMESTAMP type.currentTimestamp(int precision) SQLDataType.TIMESTAMP type with the specified fractional
seconds precision.currentTimestamp(Field<Integer> precision) SQLDataType.TIMESTAMP type with the specified fractional
seconds precision.CURRENT_USER function.DATE.DATE.DATE.DATE_ADD function.DATE_ADD function.DATE_ADD function.DATE_ADD function.DATE_ADD function.DATE_ADD function.DATE_ADD function.DATE_ADD function.endDate - startDate in
number of days.endDate - startDate in
number of days.endDate - startDate in terms
of part.endDate - startDate in terms
of part.endDate - startDate in terms
of part.endDate - startDate in terms
of part.endDate - startDate in
number of days.endDate - startDate in
number of days.static @NotNull Statementdeclare(Collection<? extends Variable<?>> variables) static @NotNull Statementstatic <T> @NotNull Declaration<T>static @NotNull Casedecode()Case statement.static <Z,
T> @NotNull Field<Z> DECODE(expression, search, result[, search , result]… [, default])
function.static <Z,
T> @NotNull Field<Z> DECODE(expression, search, result[, search , result]… [, default])
function.static <Z,
T> @NotNull Field<Z> decode(T value,
T search,
Z result) DECODE(expression, search, result[, search , result]… [, default])
function.static <Z,
T> @NotNull Field<Z> DECODE(expression, search, result[, search , result]… [, default])
function.default_()DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.static <T> @NotNull Field<T>DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.static <T> @NotNull Field<T>DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.static <T> @NotNull Field<T>DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.static <T> @NotNull Field<T>defaultValue(Class<T> type) DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.static <T> @NotNull Field<T>defaultValue(DataType<T> type) DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.static <T> @NotNull Field<T>defaultValue(Field<T> field) DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.static @NotNull Field<BigDecimal>DEGREES function.static @NotNull Field<BigDecimal>DEGREES function.static <R extends Record>
@NotNull DeleteUsingStep<R>static <R extends Record>
@NotNull DeleteUsingStep<R>deleteFrom(Table<R> table) static @NotNull Conditiondeleting()DELETING function.static @NotNull WindowOverStep<Integer>dense_rank() over ([analytic clause]) function.static @NotNull OrderedAggregateFunction<Integer>denseRank(Collection<? extends Field<?>> fields) dense_rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<Integer>dense_rank(expr) within group (order by [order clause])
ordered-set aggregate function.DIGITS function.DIGITS function.static @NotNull Domain<?>DOMAIN reference.static <T> @NotNull Domain<T>DOMAIN reference.static <T> @NotNull Domain<T>DOMAIN reference.static @NotNull Domain<?>DOMAIN reference.static <T> @NotNull Domain<T>DOMAIN reference.static <T> @NotNull Domain<T>DOMAIN reference.static DropDatabaseFinalStepdropDatabase(String database) DROP DATABASE statement.static DropDatabaseFinalStepdropDatabase(Catalog database) DROP DATABASE statement.static DropDatabaseFinalStepdropDatabase(Name database) DROP DATABASE statement.static DropDatabaseFinalStepdropDatabaseIfExists(String database) DROP DATABASE IF EXISTS statement.static DropDatabaseFinalStepdropDatabaseIfExists(Catalog database) DROP DATABASE IF EXISTS statement.static DropDatabaseFinalStepdropDatabaseIfExists(Name database) DROP DATABASE IF EXISTS statement.static DropDomainCascadeStepdropDomain(String domain) DROP DOMAIN statement.static DropDomainCascadeStepdropDomain(Domain<?> domain) DROP DOMAIN statement.static DropDomainCascadeStepdropDomain(Name domain) DROP DOMAIN statement.static DropDomainCascadeStepdropDomainIfExists(String domain) DROP DOMAIN IF EXISTS statement.static DropDomainCascadeStepdropDomainIfExists(Domain<?> domain) DROP DOMAIN IF EXISTS statement.static DropDomainCascadeStepdropDomainIfExists(Name domain) DROP DOMAIN IF EXISTS statement.static DDLQuerydropFunction(String function) DROP FUNCTION statement.static DDLQuerydropFunction(Name function) DROP FUNCTION statement.static DDLQuerydropFunctionIfExists(String function) DROP FUNCTION IF EXISTS statement.static DDLQuerydropFunctionIfExists(Name function) DROP FUNCTION IF EXISTS statement.static DropIndexOnStepDROP INDEX statement.static DropIndexOnStepDROP INDEX statement.static DropIndexOnStepDROP INDEX statement.static DropIndexOnStepdropIndexIfExists(String index) DROP INDEX IF EXISTS statement.static DropIndexOnStepdropIndexIfExists(Index index) DROP INDEX IF EXISTS statement.static DropIndexOnStepdropIndexIfExists(Name index) DROP INDEX IF EXISTS statement.static DropViewFinalStepdropMaterializedView(String view) DROP MATERIALIZED VIEW statement.static DropViewFinalStepdropMaterializedView(Name view) DROP MATERIALIZED VIEW statement.static DropViewFinalStepdropMaterializedView(Table<?> view) DROP MATERIALIZED VIEW statement.static DropViewFinalStepDROP MATERIALIZED VIEW IF EXISTS statement.static DropViewFinalStepDROP MATERIALIZED VIEW IF EXISTS statement.static DropViewFinalStepdropMaterializedViewIfExists(Table<?> view) DROP MATERIALIZED VIEW IF EXISTS statement.static DDLQuerydropProcedure(String procedure) DROP PROCEDURE statement.static DDLQuerydropProcedure(Name procedure) DROP PROCEDURE statement.static DDLQuerydropProcedureIfExists(String procedure) DROP PROCEDURE IF EXISTS statement.static DDLQuerydropProcedureIfExists(Name procedure) DROP PROCEDURE IF EXISTS statement.static DropSchemaStepdropSchema(String schema) DROP SCHEMA statement.static DropSchemaStepdropSchema(Name schema) DROP SCHEMA statement.static DropSchemaStepdropSchema(Schema schema) DROP SCHEMA statement.static DropSchemaStepdropSchemaIfExists(String schema) DROP SCHEMA IF EXISTS statement.static DropSchemaStepdropSchemaIfExists(Name schema) DROP SCHEMA IF EXISTS statement.static DropSchemaStepdropSchemaIfExists(Schema schema) DROP SCHEMA IF EXISTS statement.static DropSequenceFinalStepdropSequence(String sequence) DROP SEQUENCE statement.static DropSequenceFinalStepdropSequence(Name sequence) DROP SEQUENCE statement.static DropSequenceFinalStepdropSequence(Sequence<?> sequence) DROP SEQUENCE statement.static DropSequenceFinalStepdropSequenceIfExists(String sequence) DROP SEQUENCE IF EXISTS statement.static DropSequenceFinalStepdropSequenceIfExists(Name sequence) DROP SEQUENCE IF EXISTS statement.static DropSequenceFinalStepdropSequenceIfExists(Sequence<?> sequence) DROP SEQUENCE IF EXISTS statement.static DropTableStepDROP TABLE statement.static DropTableStepDROP TABLE statement.static DropTableStepDROP TABLE statement.static DropTableStepdropTableIfExists(String table) DROP TABLE IF EXISTS statement.static DropTableStepdropTableIfExists(Name table) DROP TABLE IF EXISTS statement.static DropTableStepdropTableIfExists(Table<?> table) DROP TABLE IF EXISTS statement.static DropTableStepdropTemporaryTable(String table) DROP TEMPORARY TABLE statement.static DropTableStepdropTemporaryTable(Name table) DROP TEMPORARY TABLE statement.static DropTableStepdropTemporaryTable(Table<?> table) DROP TEMPORARY TABLE statement.static DropTableStepdropTemporaryTableIfExists(String table) DROP TEMPORARY TABLE IF EXISTS statement.static DropTableStepdropTemporaryTableIfExists(Name table) DROP TEMPORARY TABLE IF EXISTS statement.static DropTableStepdropTemporaryTableIfExists(Table<?> table) DROP TEMPORARY TABLE IF EXISTS statement.static DropTriggerOnStepdropTrigger(String trigger) DROP TRIGGER statement.static DropTriggerOnStepdropTrigger(Name trigger) DROP TRIGGER statement.static DropTriggerOnStepdropTrigger(Trigger trigger) DROP TRIGGER statement.static DropTriggerOnStepdropTriggerIfExists(String trigger) DROP TRIGGER IF EXISTS statement.static DropTriggerOnStepdropTriggerIfExists(Name trigger) DROP TRIGGER IF EXISTS statement.static DropTriggerOnStepdropTriggerIfExists(Trigger trigger) DROP TRIGGER IF EXISTS statement.static DropTypeStepDROP TYPE statement.static DropTypeStepDROP TYPE statement.static DropTypeStepdropType(Collection<? extends Type<?>> types) DROP TYPE statement.static DropTypeStepDROP TYPE statement.static DropTypeStepDROP TYPE statement.static DropTypeStepDROP TYPE statement.static DropTypeStepDROP TYPE statement.static DropTypeStepdropTypeIfExists(String types) DROP TYPE IF EXISTS statement.static DropTypeStepdropTypeIfExists(String... types) DROP TYPE IF EXISTS statement.static DropTypeStepdropTypeIfExists(Collection<? extends Type<?>> types) DROP TYPE IF EXISTS statement.static DropTypeStepdropTypeIfExists(Name types) DROP TYPE IF EXISTS statement.static DropTypeStepdropTypeIfExists(Name... types) DROP TYPE IF EXISTS statement.static DropTypeStepdropTypeIfExists(Type<?> types) DROP TYPE IF EXISTS statement.static DropTypeStepdropTypeIfExists(Type<?>... types) DROP TYPE IF EXISTS statement.static DropViewFinalStepDROP VIEW statement.static DropViewFinalStepDROP VIEW statement.static DropViewFinalStepDROP VIEW statement.static DropViewFinalStepdropViewIfExists(String view) DROP VIEW IF EXISTS statement.static DropViewFinalStepdropViewIfExists(Name view) DROP VIEW IF EXISTS statement.static DropViewFinalStepdropViewIfExists(Table<?> view) DROP VIEW IF EXISTS statement.dual()DUAL table to be used for syntactic completeness.static @NotNull Field<BigDecimal>e()E function.static @NotNull GroupFieldstatic @NotNull Stringreplace(Field, String, String) to escape
data for use with Field.like(Field, char).replace(Field, String, String) to escape
data for use with Field.like(Field, char).static @NotNull AggregateFunction<Boolean>EVERY function, an alias for the BOOL_AND function.static @NotNull AggregateFunction<Boolean>EVERY function, an alias for the BOOL_AND function.static <T> @NotNull Field<T>EXCLUDED function.static @NotNull StatementEXECUTE function.static @NotNull StatementEXECUTE function.static @NotNull Statementstatic @NotNull ConditionEXISTS function.static @NotNull ExitWhenStepexit()EXIT statement for use in procedural code.static @NotNull ExitWhenStepEXIT statement for use in procedural code.static @NotNull StatementEXIT statement for use in procedural code.static @NotNull StatementEXIT statement for use in procedural code.static @NotNull Field<BigDecimal>EXP function.static @NotNull Field<BigDecimal>EXP function.static @NotNull FalseCondition that will always evaluate to
FALSE.static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>FIELD function.FIELD(expr, expr1, expr2, …) function.FIELD(expr, expr1, expr2, …) function.static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>field(SelectField<T> field) SelectField in a general-purpose Fieldstatic <T> @NotNull Field<T>static <T> @NotNull Field<T>finalTable(Insert<R> query) finalTable(Merge<R> query) finalTable(Update<R> query) static <T> @NotNull WindowIgnoreNullsStep<T>firstValue(Field<T> field) first_value(field) over ([analytic clause]) function.FLOOR function.floor(T value) FLOOR function.static <T> @NotNull ForInStep<T>FOR loop for use in procedural code.static @NotNull ConstraintForeignKeyReferencesStep1<?>foreignKey(String field1) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStepNforeignKey(String... fields) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep2<?,?> foreignKey(String field1,
String field2) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep3<?,?,?> foreignKey(String field1,
String field2,
String field3) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep4<?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep5<?,?,?,?,?> FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep6<?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep7<?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep8<?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep9<?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep10<?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep11<?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep12<?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11,
String field12) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep13<?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11,
String field12,
String field13) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep14<?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11,
String field12,
String field13,
String field14) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep15<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11,
String field12,
String field13,
String field14,
String field15) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep16<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11,
String field12,
String field13,
String field14,
String field15,
String field16) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep17<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11,
String field12,
String field13,
String field14,
String field15,
String field16,
String field17) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep18<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11,
String field12,
String field13,
String field14,
String field15,
String field16,
String field17,
String field18) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep19<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11,
String field12,
String field13,
String field14,
String field15,
String field16,
String field17,
String field18,
String field19) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep20<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11,
String field12,
String field13,
String field14,
String field15,
String field16,
String field17,
String field18,
String field19,
String field20) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep21<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11,
String field12,
String field13,
String field14,
String field15,
String field16,
String field17,
String field18,
String field19,
String field20,
String field21) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep22<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(String field1,
String field2,
String field3,
String field4,
String field5,
String field6,
String field7,
String field8,
String field9,
String field10,
String field11,
String field12,
String field13,
String field14,
String field15,
String field16,
String field17,
String field18,
String field19,
String field20,
String field21,
String field22) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStepNforeignKey(Collection<? extends Field<?>> fields) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStepNforeignKey(Field<?>... fields) FOREIGN KEY clause to the CONSTRAINT.static <T1> @NotNull ConstraintForeignKeyReferencesStep1<T1>foreignKey(Field<T1> field1) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2> @NotNull ConstraintForeignKeyReferencesStep2<T1,T2> foreignKey(Field<T1> field1,
Field<T2> field2) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3>
@NotNull ConstraintForeignKeyReferencesStep3<T1,T2,T3> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4>
@NotNull ConstraintForeignKeyReferencesStep4<T1,T2,T3,T4> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5>
@NotNull ConstraintForeignKeyReferencesStep5<T1,T2,T3,T4,T5> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6>
@NotNull ConstraintForeignKeyReferencesStep6<T1,T2,T3,T4,T5,T6> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7>
@NotNull ConstraintForeignKeyReferencesStep7<T1,T2,T3,T4,T5,T6,T7> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8>
@NotNull ConstraintForeignKeyReferencesStep8<T1,T2,T3,T4,T5,T6,T7,T8> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9>
@NotNull ConstraintForeignKeyReferencesStep9<T1,T2,T3,T4,T5,T6,T7,T8,T9> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull ConstraintForeignKeyReferencesStep10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull ConstraintForeignKeyReferencesStep11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull ConstraintForeignKeyReferencesStep12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull ConstraintForeignKeyReferencesStep13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull ConstraintForeignKeyReferencesStep14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull ConstraintForeignKeyReferencesStep15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull ConstraintForeignKeyReferencesStep16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull ConstraintForeignKeyReferencesStep17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull ConstraintForeignKeyReferencesStep18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull ConstraintForeignKeyReferencesStep19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull ConstraintForeignKeyReferencesStep20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull ConstraintForeignKeyReferencesStep21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21) FOREIGN KEY clause to the CONSTRAINT.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull ConstraintForeignKeyReferencesStep22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> foreignKey(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21,
Field<T22> field22) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep1<?>foreignKey(Name field1) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStepNforeignKey(Name... fields) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep2<?,?> foreignKey(Name field1,
Name field2) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep3<?,?,?> foreignKey(Name field1,
Name field2,
Name field3) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep4<?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep5<?,?,?,?,?> FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep6<?,?,?,?,?,?> FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep7<?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep8<?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep9<?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep10<?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep11<?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep12<?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep13<?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep14<?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep15<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep16<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep17<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep18<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17,
Name field18) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep19<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17,
Name field18,
Name field19) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep20<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17,
Name field18,
Name field19,
Name field20) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep21<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17,
Name field18,
Name field19,
Name field20,
Name field21) FOREIGN KEY clause to the CONSTRAINT.static @NotNull ConstraintForeignKeyReferencesStep22<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?> foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17,
Name field18,
Name field19,
Name field20,
Name field21,
Name field22) FOREIGN KEY clause to the CONSTRAINT.static <T> @NotNull Field<T>function() can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull Field<T>function() can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull Field<T>function() can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull Field<T>function() can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.generateSeries(int from,
int to) from to
to (inclusive).generateSeries(int from,
int to,
int step) from to
to (inclusive), increasing values by step.generateSeries(int from,
int to,
Field<Integer> step) from to
to (inclusive), increasing values by step.generateSeries(int from,
Field<Integer> to) from to
to (inclusive).generateSeries(int from,
Field<Integer> to,
int step) from to
to (inclusive), increasing values by step.generateSeries(int from,
Field<Integer> to,
Field<Integer> step) from to
to (inclusive), increasing values by step.generateSeries(Field<Integer> from,
int to) from to
to (inclusive).generateSeries(Field<Integer> from,
int to,
int step) from to
to (inclusive), increasing values by step.generateSeries(Field<Integer> from,
int to,
Field<Integer> step) from to
to (inclusive), increasing values by step.generateSeries(Field<Integer> from,
Field<Integer> to) from to
to (inclusive).generateSeries(Field<Integer> from,
Field<Integer> to,
int step) from to
to (inclusive), increasing values by step.from to
to (inclusive), increasing values by step.static <T> @NotNull DataType<T>getDataType(Class<T> type) static @NotNull StatementGOTO function.static GrantOnStepgrant(Collection<? extends Privilege> privileges) GRANT statement.static GrantOnStepGRANT statement.static GrantOnStepGRANT statement.static <T> @NotNull Field<T>static <T> @NotNull Field<T>greatest(T value,
T... values) static @NotNull GroupConcatOrderByStepgroupConcat(Field<?> field) static @NotNull AggregateFunction<String>groupConcat(Field<?> field,
String separator) groupConcat(Field) and
GroupConcatSeparatorStep.separator(String) instead.static @NotNull GroupConcatOrderByStepgroupConcatDistinct(Field<?> field) groupId()GROUP_ID() aggregation function to be used along
with CUBE, ROLLUP, and
GROUPING SETS groupings.CUBE, ROLLUP, and GROUPING SETS
groupings.groupingId(Field<?>... fields) CUBE, ROLLUP, and
GROUPING SETS groupings.static @NotNull GroupFieldgroupingSets(Collection<? extends Field<?>>... fieldSets) static @NotNull GroupFieldgroupingSets(Field<?>... fields) static @NotNull GroupFieldgroupingSets(Field<?>[]... fieldSets) static @NotNull WindowSpecificationRowsAndStepWindowSpecification with a GROUPS clause.static @NotNull WindowSpecificationRowsAndStepgroupsBetweenFollowing(int number) WindowSpecification with a GROUPS clause.static @NotNull WindowSpecificationRowsAndStepgroupsBetweenPreceding(int number) WindowSpecification with a GROUPS clause.static @NotNull WindowSpecificationRowsAndStepWindowSpecification with a GROUPS clause.static @NotNull WindowSpecificationRowsAndStepWindowSpecification with a GROUPS clause.static @NotNull WindowSpecificationExcludeStepWindowSpecification with a GROUPS clause.static @NotNull WindowSpecificationExcludeStepgroupsFollowing(int number) WindowSpecification with a GROUPS clause.static @NotNull WindowSpecificationExcludeStepgroupsPreceding(int number) WindowSpecification with a GROUPS clause.static @NotNull WindowSpecificationExcludeStepWindowSpecification with a GROUPS clause.static @NotNull WindowSpecificationExcludeStepWindowSpecification with a GROUPS clause.static @NotNull IfThenStepIF statement for use in procedural code.static <T> @NotNull Field<T>IF(condition, ifTrue, ifFalse) function.static <T> @NotNull Field<T>IF(condition, ifTrue, ifFalse) function.static <T> @NotNull Field<T>IF(condition, ifTrue, ifFalse) function.static <T> @NotNull Field<T>IF(condition, ifTrue, ifFalse) function.static <T> @NotNull Field<T>IFNULL function, an alias for the NVL function.static <T> @NotNull Field<T>IFNULL function, an alias for the NVL function.static <T> @NotNull Field<T>IFNULL function, an alias for the NVL function.static <T> @NotNull Field<T>ifnull(T value,
T defaultValue) IFNULL function, an alias for the NVL function.static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Field<T>static <T> @NotNull Parameter<T>IN parameter.static <T> @NotNull Parameter<T>IN parameter.static @NotNull Indexinline(boolean value) inline(byte value) static @NotNull Param<byte[]>inline(byte[] value) inline(char character) inline(double value) inline(float value) inline(int value) inline(long value) inline(short value) inline(CharSequence character) static <T> @NotNull Param<T>static <T> @NotNull Param<T>static <T> @NotNull Param<T>static @NotNull Param<BigDecimal>inline(BigDecimal value) static @NotNull Param<BigInteger>inline(BigInteger value) static @NotNull Param<LocalDateTime>inline(LocalDateTime value) static @NotNull Param<OffsetDateTime>inline(OffsetDateTime value) static @NotNull Param<OffsetTime>inline(OffsetTime value) static <T> @NotNull Param<T>inline(T value) static @NotNull ConditionCondition.static <T> @NotNull Field<T>Field.static @NotNull QueryPartQueryPart.static @NotNull StatementStatement.static <T> @NotNull Parameter<T>IN OUT parameter.static <T> @NotNull Parameter<T>IN OUT parameter.insert(Field<String> in,
Field<? extends Number> startIndex,
Field<? extends Number> length,
Field<String> placing) static @NotNull ConditionINSERTING function.static <R extends Record>
@NotNull InsertSetStep<R>insertInto(Table<R> into) static <R extends Record>
@NotNull InsertValuesStepN<R>insertInto(Table<R> into,
Collection<? extends Field<?>> fields) static <R extends Record>
@NotNull InsertValuesStepN<R>insertInto(Table<R> into,
Field<?>... fields) static <R extends Record,
T1>
@NotNull InsertValuesStep1<R,T1> insertInto(Table<R> into,
Field<T1> field1) static <R extends Record,
T1,
T2>
@NotNull InsertValuesStep2<R,T1,T2> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2) static <R extends Record,
T1,
T2,
T3>
@NotNull InsertValuesStep3<R,T1,T2,T3> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3) static <R extends Record,
T1,
T2,
T3,
T4>
@NotNull InsertValuesStep4<R,T1,T2,T3,T4> static <R extends Record,
T1,
T2,
T3,
T4,
T5>
@NotNull InsertValuesStep5<R,T1,T2,T3,T4,T5> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6>
@NotNull InsertValuesStep6<R,T1,T2,T3,T4,T5,T6> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7>
@NotNull InsertValuesStep7<R,T1,T2,T3,T4,T5,T6,T7> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8>
@NotNull InsertValuesStep8<R,T1,T2,T3,T4,T5,T6,T7,T8> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9>
@NotNull InsertValuesStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull InsertValuesStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull InsertValuesStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull InsertValuesStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull InsertValuesStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull InsertValuesStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull InsertValuesStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull InsertValuesStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull InsertValuesStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull InsertValuesStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull InsertValuesStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull InsertValuesStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull InsertValuesStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21) static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull InsertValuesStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21,
Field<T22> field22) TIMESTAMP WITH TIME ZONE.TIMESTAMP WITH TIME ZONE.TIMESTAMP WITH TIME ZONE.static <T> @NotNull Field<T>ISNULL function, an alias for the NVL function.static <T> @NotNull Field<T>ISNULL function, an alias for the NVL function.static <T> @NotNull Field<T>ISNULL function, an alias for the NVL function.static <T> @NotNull Field<T>isnull(T value,
T defaultValue) ISNULL function, an alias for the NVL function.isoDayOfWeek(Temporal value) isoDayOfWeek(Date value) isoDayOfWeek(Field<?> field) static @NotNull JSONArrayNullStep<JSON>jsonArray(Collection<? extends Field<?>> fields) JSON_ARRAY function.static @NotNull JSONArrayNullStep<JSON>JSON_ARRAY function.static @NotNull JSONArrayAggOrderByStep<JSON>jsonArrayAgg(Field<?> value) static @NotNull JSONArrayAggOrderByStep<JSON>jsonArrayAggDistinct(Field<?> value) static @NotNull JSONArrayNullStep<JSONB>jsonbArray(Collection<? extends Field<?>> fields) JSONB_ARRAY function.static @NotNull JSONArrayNullStep<JSONB>jsonbArray(Field<?>... fields) JSONB_ARRAY function.static @NotNull JSONArrayAggOrderByStep<JSONB>jsonbArrayAgg(Field<?> value) static @NotNull JSONArrayAggOrderByStep<JSONB>jsonbArrayAggDistinct(Field<?> value) static @NotNull JSONExistsOnStepjsonbExists(Field<JSONB> field,
String path) static @NotNull JSONExistsOnStepjsonbExists(Field<JSONB> field,
Field<String> path) jsonbGetAttribute(Field<JSONB> field,
String attribute) JSONB_GET_ATTRIBUTE function.jsonbGetAttribute(Field<JSONB> field,
Field<String> attribute) JSONB_GET_ATTRIBUTE function.jsonbGetAttribute(JSONB field,
String attribute) JSONB_GET_ATTRIBUTE function.jsonbGetAttribute(JSONB field,
Field<String> attribute) JSONB_GET_ATTRIBUTE function.jsonbGetAttributeAsText(Field<JSONB> field,
String attribute) JSONB_GET_ATTRIBUTE_AS_TEXT function.jsonbGetAttributeAsText(Field<JSONB> field,
Field<String> attribute) JSONB_GET_ATTRIBUTE_AS_TEXT function.jsonbGetAttributeAsText(JSONB field,
String attribute) JSONB_GET_ATTRIBUTE_AS_TEXT function.jsonbGetAttributeAsText(JSONB field,
Field<String> attribute) JSONB_GET_ATTRIBUTE_AS_TEXT function.jsonbGetElement(Field<JSONB> field,
int index) JSONB_GET_ELEMENT function.jsonbGetElement(Field<JSONB> field,
Field<Integer> index) JSONB_GET_ELEMENT function.jsonbGetElement(JSONB field,
int index) JSONB_GET_ELEMENT function.jsonbGetElement(JSONB field,
Field<Integer> index) JSONB_GET_ELEMENT function.jsonbGetElementAsText(Field<JSONB> field,
int index) JSONB_GET_ELEMENT_AS_TEXT function.jsonbGetElementAsText(Field<JSONB> field,
Field<Integer> index) JSONB_GET_ELEMENT_AS_TEXT function.jsonbGetElementAsText(JSONB field,
int index) JSONB_GET_ELEMENT_AS_TEXT function.jsonbGetElementAsText(JSONB field,
Field<Integer> index) JSONB_GET_ELEMENT_AS_TEXT function.jsonbInsert(Field<JSONB> field,
String path,
Object value) JSONB_INSERT function.jsonbInsert(Field<JSONB> field,
String path,
Field<?> value) JSONB_INSERT function.JSONB_INSERT function.JSONB_INSERT function.JSONB_KEYS function.JSONB_KEYS function.static @NotNull JSONObjectNullStep<JSONB>static @NotNull JSONObjectNullStep<JSONB>jsonbObject(String key,
Field<?> value) static @NotNull JSONObjectNullStep<JSONB>jsonbObject(Collection<? extends JSONEntry<?>> entries) JSONB_OBJECT function.static @NotNull JSONObjectNullStep<JSONB>jsonbObject(Field<?>... entries) Field
arguments in this method is inconsistent with that of other
overloads, such as jsonbObject(Field, Field), which
can lead to subtle bugs.static @NotNull JSONObjectNullStep<JSONB>jsonbObject(Field<String> key,
Field<?> value) static @NotNull JSONObjectNullStep<JSONB>jsonbObject(Field<String> key,
Select<? extends Record1<?>> value) static @NotNull JSONObjectNullStep<JSONB>jsonbObject(JSONEntry<?>... entries) JSONB_OBJECT function.static @NotNull JSONObjectAggNullStep<JSONB>jsonbObjectAgg(String key,
Field<?> value) static @NotNull JSONObjectAggNullStep<JSONB>jsonbObjectAgg(Field<?> field) static @NotNull JSONObjectAggNullStep<JSONB>jsonbObjectAgg(Field<String> key,
Field<?> value) static @NotNull JSONObjectAggNullStep<JSONB>jsonbObjectAgg(JSONEntry<?> entry) jsonbRemove(Field<JSONB> field,
String path) JSONB_REMOVE function.jsonbRemove(Field<JSONB> field,
Field<String> path) JSONB_REMOVE function.jsonbReplace(Field<JSONB> field,
String path,
Object value) JSONB_REPLACE function.jsonbReplace(Field<JSONB> field,
String path,
Field<?> value) JSONB_REPLACE function.JSONB_REPLACE function.JSONB_REPLACE function.JSONB_SET function.JSONB_SET function.JSONB_SET function.JSONB_SET function.static @NotNull JSONTableColumnsFirstStepjsonbTable(Field<JSONB> json,
Field<String> path) static @NotNull JSONTableColumnsFirstStepjsonbTable(JSONB json,
String path) static @NotNull JSONValueOnStep<JSONB>jsonbValue(Field<JSONB> json,
String path) static @NotNull JSONValueOnStep<JSONB>jsonbValue(Field<JSONB> json,
Field<String> path) static <T> @NotNull JSONEntry<T>jsonObject(JSONEntry...).static <T> @NotNull JSONEntry<T>jsonObject(JSONEntry...).static <T> @NotNull JSONEntry<T>jsonObject(JSONEntry...).static <T> @NotNull JSONEntry<T>jsonObject(JSONEntry...).static <T> @NotNull JSONEntry<T>jsonObject(JSONEntry...).static <T> @NotNull JSONEntry<T>jsonObject(JSONEntry...).static <T> @NotNull JSONEntry<T>jsonObject(JSONEntry...).static @NotNull JSONExistsOnStepjsonExists(Field<JSON> field,
String path) static @NotNull JSONExistsOnStepjsonExists(Field<JSON> field,
Field<String> path) jsonGetAttribute(Field<JSON> field,
String attribute) JSON_GET_ATTRIBUTE function.jsonGetAttribute(Field<JSON> field,
Field<String> attribute) JSON_GET_ATTRIBUTE function.jsonGetAttribute(JSON field,
String attribute) JSON_GET_ATTRIBUTE function.jsonGetAttribute(JSON field,
Field<String> attribute) JSON_GET_ATTRIBUTE function.jsonGetAttributeAsText(Field<JSON> field,
String attribute) JSON_GET_ATTRIBUTE_AS_TEXT function.jsonGetAttributeAsText(Field<JSON> field,
Field<String> attribute) JSON_GET_ATTRIBUTE_AS_TEXT function.jsonGetAttributeAsText(JSON field,
String attribute) JSON_GET_ATTRIBUTE_AS_TEXT function.jsonGetAttributeAsText(JSON field,
Field<String> attribute) JSON_GET_ATTRIBUTE_AS_TEXT function.jsonGetElement(Field<JSON> field,
int index) JSON_GET_ELEMENT function.jsonGetElement(Field<JSON> field,
Field<Integer> index) JSON_GET_ELEMENT function.jsonGetElement(JSON field,
int index) JSON_GET_ELEMENT function.jsonGetElement(JSON field,
Field<Integer> index) JSON_GET_ELEMENT function.jsonGetElementAsText(Field<JSON> field,
int index) JSON_GET_ELEMENT_AS_TEXT function.jsonGetElementAsText(Field<JSON> field,
Field<Integer> index) JSON_GET_ELEMENT_AS_TEXT function.jsonGetElementAsText(JSON field,
int index) JSON_GET_ELEMENT_AS_TEXT function.jsonGetElementAsText(JSON field,
Field<Integer> index) JSON_GET_ELEMENT_AS_TEXT function.jsonInsert(Field<JSON> field,
String path,
Object value) JSON_INSERT function.jsonInsert(Field<JSON> field,
String path,
Field<?> value) JSON_INSERT function.JSON_INSERT function.JSON_INSERT function.JSON_KEYS function.JSON_KEYS function.static @NotNull JSONObjectNullStep<JSON>static @NotNull JSONObjectNullStep<JSON>jsonObject(String key,
Field<?> value) static @NotNull JSONObjectNullStep<JSON>jsonObject(Collection<? extends JSONEntry<?>> entries) JSON_OBJECT function.static @NotNull JSONObjectNullStep<JSON>jsonObject(Field<?>... entries) Field
arguments in this method is inconsistent with that of other
overloads, such as jsonbObject(Field, Field), which
can lead to subtle bugs.static @NotNull JSONObjectNullStep<JSON>jsonObject(Field<String> key,
Field<?> value) static @NotNull JSONObjectNullStep<JSON>jsonObject(Field<String> key,
Select<? extends Record1<?>> value) static @NotNull JSONObjectNullStep<JSON>jsonObject(JSONEntry<?>... entries) JSON_OBJECT function.static @NotNull JSONObjectAggNullStep<JSON>jsonObjectAgg(String key,
Field<?> value) static @NotNull JSONObjectAggNullStep<JSON>jsonObjectAgg(Field<?> value) static @NotNull JSONObjectAggNullStep<JSON>jsonObjectAgg(Field<String> key,
Field<?> value) static @NotNull JSONObjectAggNullStep<JSON>jsonObjectAgg(JSONEntry<?> entry) jsonRemove(Field<JSON> field,
String path) JSON_REMOVE function.jsonRemove(Field<JSON> field,
Field<String> path) JSON_REMOVE function.jsonReplace(Field<JSON> field,
String path,
Object value) JSON_REPLACE function.jsonReplace(Field<JSON> field,
String path,
Field<?> value) JSON_REPLACE function.JSON_REPLACE function.JSON_REPLACE function.JSON_SET function.JSON_SET function.JSON_SET function.JSON_SET function.static @NotNull JSONTableColumnsFirstStepstatic @NotNull JSONTableColumnsFirstStepstatic @NotNull JSONValueOnStep<JSON>static @NotNull JSONValueOnStep<JSON>static @NotNull JSONEntryValueStepjsonObject(JSONEntry...).static @NotNull JSONEntryValueStepjsonObject(JSONEntry...).static @NotNull Keywordstatic @NotNull Labelstatic @NotNull Labelstatic <T> @NotNull WindowIgnoreNullsStep<T>lag(field) over ([analytic clause]) function.static <T> @NotNull WindowIgnoreNullsStep<T>lag(field, offset) over ([analytic clause]) function.static <T> @NotNull WindowIgnoreNullsStep<T>lag(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>lag(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>lag(field, offset) over ([analytic clause]) function.static <T> @NotNull WindowIgnoreNullsStep<T>lag(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>lag(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>last_value(field) over ([analytic clause]) function.LATERAL joined table.static <T> @NotNull WindowIgnoreNullsStep<T>lead(field) over ([analytic clause]) function.static <T> @NotNull WindowIgnoreNullsStep<T>lead(field, offset) over ([analytic clause]) function.static <T> @NotNull WindowIgnoreNullsStep<T>lead(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>lead(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>lead(field, offset) over ([analytic clause]) function.static <T> @NotNull WindowIgnoreNullsStep<T>lead(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>lead(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull Field<T>static <T> @NotNull Field<T>least(T value,
T... values) LEFT function.LEFT function.LEFT function.LEFT function.LENGTH function, an alias for the CHAR_LENGTH function.LENGTH function, an alias for the CHAR_LENGTH function.level()LEVEL function.static @NotNull Linkstatic @NotNull Linkstatic @NotNull Linkstatic @NotNull QueryPartlist(Collection<? extends QueryPart> parts) QueryParts into a new
QueryPart, with individual parts being comma-separated.static @NotNull QueryPartQueryParts into a new
QueryPart, with individual parts being comma-separated.static @NotNull OrderedAggregateFunction<String>static @NotNull OrderedAggregateFunction<String>static @NotNull OrderedAggregateFunction<String>listAggDistinct(Field<?> field) static @NotNull OrderedAggregateFunction<String>listAggDistinct(Field<?> field,
String separator) static @NotNull Field<BigDecimal>LN function.static @NotNull Field<BigDecimal>LN function.DATE.DATE.DATE.localDateAdd(LocalDate date,
Number interval) LOCAL_DATE_ADD function.localDateAdd(LocalDate date,
Number interval,
DatePart datePart) LOCAL_DATE_ADD function.localDateAdd(LocalDate date,
Field<? extends Number> interval) LOCAL_DATE_ADD function.localDateAdd(LocalDate date,
Field<? extends Number> interval,
DatePart datePart) LOCAL_DATE_ADD function.localDateAdd(Field<LocalDate> date,
Number interval) LOCAL_DATE_ADD function.localDateAdd(Field<LocalDate> date,
Number interval,
DatePart datePart) LOCAL_DATE_ADD function.localDateAdd(Field<LocalDate> date,
Field<? extends Number> interval) LOCAL_DATE_ADD function.LOCAL_DATE_ADD function.localDateDiff(LocalDate endDate,
LocalDate startDate) endDate - startDate in
number of days.localDateDiff(LocalDate endDate,
Field<LocalDate> startDate) endDate - startDate in
number of days.localDateDiff(DatePart part,
LocalDate startDate,
LocalDate endDate) endDate - startDate in terms
of part.localDateDiff(DatePart part,
LocalDate startDate,
Field<LocalDate> endDate) endDate - startDate in terms
of part.localDateDiff(DatePart part,
Field<LocalDate> startDate,
LocalDate endDate) endDate - startDate in terms
of part.endDate - startDate in terms
of part.localDateDiff(Field<LocalDate> endDate,
LocalDate startDate) endDate - startDate in
number of days.localDateDiff(Field<LocalDate> endDate,
Field<LocalDate> startDate) endDate - startDate in
number of days.localDateSub(LocalDate date,
Number interval) localDateSub(LocalDate date,
Number interval,
DatePart datePart) localDateSub(LocalDate date,
Field<? extends Number> interval,
DatePart datePart) localDateSub(Field<LocalDate> date,
Number interval,
DatePart datePart) localDateSub(Field<LocalDate> date,
Field<? extends Number> interval) static @NotNull Field<LocalDateTime>localDateTime(String value) TIMESTAMP.static @NotNull Field<LocalDateTime>localDateTime(LocalDateTime value) TIMESTAMP.static @NotNull Field<LocalDateTime>localDateTime(Field<LocalDateTime> field) TIMESTAMP.static @NotNull Field<LocalDateTime>localDateTimeAdd(LocalDateTime date,
Number interval) LOCAL_DATE_TIME_ADD function.static @NotNull Field<LocalDateTime>localDateTimeAdd(LocalDateTime date,
Number interval,
DatePart datePart) LOCAL_DATE_TIME_ADD function.static @NotNull Field<LocalDateTime>localDateTimeAdd(LocalDateTime date,
Field<? extends Number> interval) LOCAL_DATE_TIME_ADD function.static @NotNull Field<LocalDateTime>localDateTimeAdd(LocalDateTime date,
Field<? extends Number> interval,
DatePart datePart) LOCAL_DATE_TIME_ADD function.static @NotNull Field<LocalDateTime>localDateTimeAdd(Field<LocalDateTime> date,
Number interval) LOCAL_DATE_TIME_ADD function.static @NotNull Field<LocalDateTime>localDateTimeAdd(Field<LocalDateTime> date,
Number interval,
DatePart datePart) LOCAL_DATE_TIME_ADD function.static @NotNull Field<LocalDateTime>localDateTimeAdd(Field<LocalDateTime> date,
Field<? extends Number> interval) LOCAL_DATE_TIME_ADD function.static @NotNull Field<LocalDateTime>localDateTimeAdd(Field<LocalDateTime> date,
Field<? extends Number> interval,
DatePart datePart) LOCAL_DATE_TIME_ADD function.static @NotNull Field<DayToSecond>localDateTimeDiff(LocalDateTime timestamp1,
LocalDateTime timestamp2) INTERVAL DAY TO SECOND
type.static @NotNull Field<DayToSecond>localDateTimeDiff(LocalDateTime timestamp1,
Field<LocalDateTime> timestamp2) INTERVAL DAY TO SECOND
type.localDateTimeDiff(DatePart part,
LocalDateTime startDate,
LocalDateTime endDate) endDate - startDate in terms
of part.localDateTimeDiff(DatePart part,
LocalDateTime startDate,
Field<LocalDateTime> endDate) endDate - startDate in terms
of part.localDateTimeDiff(DatePart part,
Field<LocalDateTime> startDate,
LocalDateTime endDate) endDate - startDate in terms
of part.localDateTimeDiff(DatePart part,
Field<LocalDateTime> startDate,
Field<LocalDateTime> endDate) endDate - startDate in terms
of part.static @NotNull Field<DayToSecond>localDateTimeDiff(Field<LocalDateTime> timestamp1,
LocalDateTime timestamp2) INTERVAL DAY TO SECOND
type.static @NotNull Field<DayToSecond>localDateTimeDiff(Field<LocalDateTime> timestamp1,
Field<LocalDateTime> timestamp2) INTERVAL DAY TO SECOND
type.static @NotNull Field<LocalDateTime>localDateTimeSub(LocalDateTime timestamp,
Number interval) static @NotNull Field<LocalDateTime>localDateTimeSub(LocalDateTime date,
Number interval,
DatePart datePart) static @NotNull Field<LocalDateTime>localDateTimeSub(LocalDateTime date,
Field<? extends Number> interval,
DatePart datePart) static @NotNull Field<LocalDateTime>localDateTimeSub(Field<LocalDateTime> date,
Number interval,
DatePart datePart) static @NotNull Field<LocalDateTime>localDateTimeSub(Field<LocalDateTime> timestamp,
Field<? extends Number> interval) static @NotNull Field<LocalDateTime>localDateTimeSub(Field<LocalDateTime> date,
Field<? extends Number> interval,
DatePart datePart) TIME.TIME.TIME.static @NotNull Field<BigDecimal>LOG function.static @NotNull Field<BigDecimal>LOG function.static @NotNull Field<BigDecimal>LOG function.static @NotNull Field<BigDecimal>LOG function.static @NotNull Field<BigDecimal>LOG10 function.static @NotNull Field<BigDecimal>LOG10 function.static @NotNull Statementloop(Collection<? extends Statement> statements) LOOP for use in procedural code.static @NotNull StatementLOOP for use in procedural code.LOWER function.LOWER function.LPAD function.LPAD function.LPAD function.LPAD function.LPAD function.LPAD function.LTRIM function.LTRIM function.LTRIM function.LTRIM function.LTRIM function.LTRIM function.static <T> @NotNull AggregateFunction<T>MAX function.static <T> @NotNull AggregateFunction<T>maxDistinct(Field<T> field) MAX_DISTINCT function.MD5 function.MD5 function.static @NotNull AggregateFunction<BigDecimal>MEDIAN function.static <R extends Record>
@NotNull MergeUsingStep<R>static <R extends Record>
@NotNull MergeKeyStepN<R>mergeInto(Table<R> table,
Collection<? extends Field<?>> fields) mergeInto(Table)static <R extends Record>
@NotNull MergeKeyStepN<R>mergeInto(Table)static <R extends Record,
T1>
@NotNull MergeKeyStep1<R,T1> mergeInto(Table)static <R extends Record,
T1,
T2>
@NotNull MergeKeyStep2<R,T1,T2> mergeInto(Table)static <R extends Record,
T1,
T2,
T3>
@NotNull MergeKeyStep3<R,T1,T2,T3> mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4>
@NotNull MergeKeyStep4<R,T1,T2,T3,T4> mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5>
@NotNull MergeKeyStep5<R,T1,T2,T3,T4,T5> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6>
@NotNull MergeKeyStep6<R,T1,T2,T3,T4,T5,T6> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7>
@NotNull MergeKeyStep7<R,T1,T2,T3,T4,T5,T6,T7> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8>
@NotNull MergeKeyStep8<R,T1,T2,T3,T4,T5,T6,T7,T8> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9>
@NotNull MergeKeyStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull MergeKeyStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull MergeKeyStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull MergeKeyStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull MergeKeyStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull MergeKeyStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull MergeKeyStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull MergeKeyStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull MergeKeyStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull MergeKeyStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull MergeKeyStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull MergeKeyStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull MergeKeyStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21) mergeInto(Table)static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull MergeKeyStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21,
Field<T22> field22) mergeInto(Table)microsecond(Temporal value) microsecond(Date value) microsecond(Field<?> field) MID function, an alias for the SUBSTRING function.MID function, an alias for the SUBSTRING function.MID function, an alias for the SUBSTRING function.MID function, an alias for the SUBSTRING function.MID function, an alias for the SUBSTRING function.MID function, an alias for the SUBSTRING function.millennium(Temporal value) millennium(Date value) millennium(Field<?> field) millisecond(Temporal value) millisecond(Date value) millisecond(Field<?> field) static <T> @NotNull AggregateFunction<T>MIN function.static <T> @NotNull AggregateFunction<T>minDistinct(Field<T> field) MIN_DISTINCT function.static @NotNull OrderedAggregateFunctionOfDeferredTypemode()mode() within group (oder by [order clause]) ordered
aggregate function.static <T> @NotNull AggregateFunction<T>mode(field) aggregate function.MULTISET operator to nest subqueries.static @NotNull ArrayAggOrderByStep<Result<Record>>multisetAgg(Collection<? extends SelectField<?>> fields) MULTISET_AGG aggregate function to nest group
contents.static @NotNull ArrayAggOrderByStep<Result<Record>>multisetAgg(Field<?>... fields) static @NotNull ArrayAggOrderByStep<Result<Record>>multisetAgg(SelectField<?>... fields) MULTISET_AGG aggregate function to nest group
contents.static <T1> @NotNull ArrayAggOrderByStep<Result<Record1<T1>>>multisetAgg(SelectField<T1> field1) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2> @NotNull ArrayAggOrderByStep<Result<Record2<T1,T2>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3>
@NotNull ArrayAggOrderByStep<Result<Record3<T1,T2,T3>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4>
@NotNull ArrayAggOrderByStep<Result<Record4<T1,T2,T3,T4>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5>
@NotNull ArrayAggOrderByStep<Result<Record5<T1,T2,T3,T4,T5>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6>
@NotNull ArrayAggOrderByStep<Result<Record6<T1,T2,T3,T4,T5,T6>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7>
@NotNull ArrayAggOrderByStep<Result<Record7<T1,T2,T3,T4,T5,T6,T7>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8>
@NotNull ArrayAggOrderByStep<Result<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9>
@NotNull ArrayAggOrderByStep<Result<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull ArrayAggOrderByStep<Result<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull ArrayAggOrderByStep<Result<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull ArrayAggOrderByStep<Result<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull ArrayAggOrderByStep<Result<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull ArrayAggOrderByStep<Result<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull ArrayAggOrderByStep<Result<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull ArrayAggOrderByStep<Result<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull ArrayAggOrderByStep<Result<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull ArrayAggOrderByStep<Result<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull ArrayAggOrderByStep<Result<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull ArrayAggOrderByStep<Result<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull ArrayAggOrderByStep<Result<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20,
SelectField<T21> field21) MULTISET_AGG aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull ArrayAggOrderByStep<Result<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>> multisetAgg(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20,
SelectField<T21> field21,
SelectField<T22> field22) MULTISET_AGG aggregate function to nest group
contents.static @NotNull ArrayAggOrderByStep<Result<Record>>multisetAggDistinct(Collection<? extends Field<?>> fields) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static @NotNull ArrayAggOrderByStep<Result<Record>>multisetAggDistinct(Field<?>... fields) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1> @NotNull ArrayAggOrderByStep<Result<Record1<T1>>>multisetAggDistinct(SelectField<T1> field1) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2> @NotNull ArrayAggOrderByStep<Result<Record2<T1,T2>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3>
@NotNull ArrayAggOrderByStep<Result<Record3<T1,T2,T3>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4>
@NotNull ArrayAggOrderByStep<Result<Record4<T1,T2,T3,T4>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5>
@NotNull ArrayAggOrderByStep<Result<Record5<T1,T2,T3,T4,T5>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6>
@NotNull ArrayAggOrderByStep<Result<Record6<T1,T2,T3,T4,T5,T6>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7>
@NotNull ArrayAggOrderByStep<Result<Record7<T1,T2,T3,T4,T5,T6,T7>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8>
@NotNull ArrayAggOrderByStep<Result<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9>
@NotNull ArrayAggOrderByStep<Result<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull ArrayAggOrderByStep<Result<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull ArrayAggOrderByStep<Result<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull ArrayAggOrderByStep<Result<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull ArrayAggOrderByStep<Result<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull ArrayAggOrderByStep<Result<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull ArrayAggOrderByStep<Result<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull ArrayAggOrderByStep<Result<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull ArrayAggOrderByStep<Result<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull ArrayAggOrderByStep<Result<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull ArrayAggOrderByStep<Result<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull ArrayAggOrderByStep<Result<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull ArrayAggOrderByStep<Result<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20,
SelectField<T21> field21) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull ArrayAggOrderByStep<Result<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>> multisetAggDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20,
SelectField<T21> field21,
SelectField<T22> field22) MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.static @NotNull Namestatic @NotNull Namestatic @NotNull Namename(Collection<String> qualifiedName) static @NotNull Namestatic @NotNull ConditionCondition that behaves like no condition being
present.static @NotNull Field<?>noField()Field that behaves like no field being present.static <T> @NotNull Field<T>Field that behaves like no field being present.static <T> @NotNull Field<T>Field that behaves like no field being present.static <T> @NotNull Field<T>Field that behaves like no field being present.static @NotNull ConditionNOT function.NOT function.static @NotNull Table<?>noTable()Table that behaves like no table being present.static @NotNull ConditionNOT EXISTS function.static @NotNull ConditionNOT UNIQUE function.now()currentTimestamp().currentTimestamp(Field).static <T> @NotNull WindowFromFirstLastStep<T>nth_value(field) over ([analytic clause]) function.static <T> @NotNull WindowFromFirstLastStep<T>nth_value(field) over ([analytic clause]) function.static @NotNull WindowOverStep<Integer>ntile(int number) ntile([number]) over ([analytic clause]) function.static @NotNull WindowOverStep<Integer>ntile([number]) over ([analytic clause]) function.static @NotNull NullCondition that will always evaluate to
NULL.static <T> @NotNull Field<T>NULLIF function.static <T> @NotNull Field<T>NULLIF function.static <T> @NotNull Field<T>NULLIF function.static <T> @NotNull Field<T>nullif(T value,
T other) NULLIF function.protected static Field<?>[]protected static Field<?>[]protected static <T> Field<T>protected static <T> Field<T>protected static <T> DataType<T>nullSafeDataType(Field<T> field) nullSafeList(Field<?>... fields) nullSafeList(Field<?>[] fields,
DataType<?> type) static <T> @NotNull Field<T>NVL function.static <T> @NotNull Field<T>NVL function.static <T> @NotNull Field<T>NVL function.static <T> @NotNull Field<T>nvl(T value,
T defaultValue) NVL function.static <Z> @NotNull Field<Z>static <Z> @NotNull Field<Z>static <Z> @NotNull Field<Z>static <Z> @NotNull Field<Z>octetLength(String string) OCTET_LENGTH function.octetLength(Field<String> string) OCTET_LENGTH function.static @NotNull Field<OffsetDateTime>offsetDateTime(String value) TIMESTAMP WITH TIME ZONE.static @NotNull Field<OffsetDateTime>offsetDateTime(OffsetDateTime value) TIMESTAMP WITH TIME ZONE.static @NotNull Field<OffsetDateTime>offsetDateTime(Field<OffsetDateTime> field) TIMESTAMP WITH TIME ZONE.static @NotNull Field<OffsetTime>offsetTime(String value) TIME WITH TIME ZONE.static @NotNull Field<OffsetTime>offsetTime(OffsetTime value) TIME WITH TIME ZONE.static @NotNull Field<OffsetTime>offsetTime(Field<OffsetTime> field) TIME WITH TIME ZONE.one()1 literal.static @NotNull Conditionor(Collection<? extends Condition> conditions) static @NotNull Conditionstatic @NotNull Conditionstatic @NotNull WindowSpecificationRowsSteporderBy(Collection<? extends OrderField<?>> fields) WindowSpecification with an ORDER BY clause.static @NotNull WindowSpecificationRowsStepWindowSpecification with an ORDER BY clause.static @NotNull WindowSpecificationRowsSteporderBy(OrderField<?>... fields) WindowSpecification with an ORDER BY clause.static <T> @NotNull Parameter<T>OUT parameter.static <T> @NotNull Parameter<T>OUT parameter.OVERLAY function.OVERLAY function.OVERLAY function.overlay(Field<String> in,
Field<String> placing,
Field<? extends Number> startIndex,
Field<? extends Number> length) OVERLAY function.param()Object /
SQLDataType.OTHER) and no initial value.static <T> @NotNull Param<T>Object /
SQLDataType.OTHER) and no initial value.static <T> @NotNull Param<T>static <T> @NotNull Param<T>static <T> @NotNull Param<T>static <T> @NotNull Param<T>static <T> @NotNull Param<T>static <T> @NotNull Param<T>static @NotNull WindowSpecificationOrderBySteppartitionBy(Collection<? extends GroupField> fields) WindowSpecification with a PARTITION BY clause.static @NotNull WindowSpecificationOrderBySteppartitionBy(GroupField... fields) WindowSpecification with a PARTITION BY clause.static @NotNull OrderedAggregateFunction<BigDecimal>percentileCont(Number number) percentile_cont([number]) within group (order by [column])
function.static @NotNull OrderedAggregateFunction<BigDecimal>percentileCont(Field<? extends Number> field) percentile_cont([number]) within group (order by [column])
function.static @NotNull OrderedAggregateFunction<BigDecimal>percentileDisc(Number number) percentile_disc([number]) within group (order by [column])
function.static @NotNull OrderedAggregateFunction<BigDecimal>percentileDisc(Field<? extends Number> field) percentile_disc([number]) within group (order by [column])
function.static @NotNull WindowOverStep<BigDecimal>percent_rank() over ([analytic clause]) function.static @NotNull OrderedAggregateFunction<Integer>percentRank(Collection<? extends Field<?>> fields) percent_rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<Integer>percentRank(Field<?>... fields) percent_rank(expr) within group (order by [order clause])
ordered-set aggregate function.Period reference.static <T> @NotNull Period<T>Period reference.static <T> @NotNull Period<T>Period reference.static @NotNull Field<BigDecimal>pi()PI function.POSITION function.POSITION function.POSITION function.POSITION function.POSITION function.POSITION function.POSITION function.POSITION function.POSITION function.POSITION function.POSITION function.POSITION function.static @NotNull Field<BigDecimal>POWER function.static @NotNull Field<BigDecimal>POWER function.static @NotNull Field<BigDecimal>POWER function.static @NotNull Field<BigDecimal>POWER function.static @NotNull ConstraintEnforcementStepprimaryKey(String... fields) PRIMARY KEY constraint.static @NotNull ConstraintEnforcementStepprimaryKey(Collection<? extends Field<?>> fields) PRIMARY KEY constraint.static @NotNull ConstraintEnforcementStepprimaryKey(Field<?>... fields) PRIMARY KEY constraint.static @NotNull ConstraintEnforcementStepprimaryKey(Name... fields) PRIMARY KEY constraint.static <T> @NotNull Field<T>PRIOR function.static @NotNull Privilegestatic @NotNull AggregateFunction<BigDecimal>PRODUCT function.static @NotNull AggregateFunction<BigDecimal>productDistinct(Field<? extends Number> field) PRODUCT_DISTINCT function.static @NotNull Queriesqueries(Collection<? extends Query> queries) static @NotNull Queriesstatic @NotNull RowCountQuerystatic @NotNull RowCountQuerystatic @NotNull RowCountQuerystatic @NotNull RowCountQuerystatic @NotNull NamequotedName(String unqualifiedName) static @NotNull NamequotedName(String... qualifiedName) static @NotNull NamequotedName(Collection<String> qualifiedName) static @NotNull Field<BigDecimal>RADIANS function.static @NotNull Field<BigDecimal>RADIANS function.static @NotNull Field<BigDecimal>rand()RAND function.static @NotNull WindowSpecificationRowsAndStepWindowSpecification with a RANGE clause.static @NotNull WindowSpecificationRowsAndSteprangeBetweenFollowing(int number) WindowSpecification with a RANGE clause.static @NotNull WindowSpecificationRowsAndSteprangeBetweenPreceding(int number) WindowSpecification with a RANGE clause.static @NotNull WindowSpecificationRowsAndStepWindowSpecification with a RANGE clause.static @NotNull WindowSpecificationRowsAndStepWindowSpecification with a RANGE clause.static @NotNull WindowSpecificationExcludeStepWindowSpecification with a RANGE clause.static @NotNull WindowSpecificationExcludeSteprangeFollowing(int number) WindowSpecification with a RANGE clause.static @NotNull WindowSpecificationExcludeSteprangePreceding(int number) WindowSpecification with a RANGE clause.static @NotNull WindowSpecificationExcludeStepWindowSpecification with a RANGE clause.static @NotNull WindowSpecificationExcludeStepWindowSpecification with a RANGE clause.static @NotNull WindowOverStep<Integer>rank()rank() over ([analytic clause]) function.static @NotNull OrderedAggregateFunction<Integer>rank(Collection<? extends Field<?>> fields) rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<Integer>rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull WindowOverStep<BigDecimal>ratioToReport(Number number) ratio_to_report([expression]) over ([analytic clause]) function.static @NotNull WindowOverStep<BigDecimal>ratioToReport(Field<? extends Number> field) ratio_to_report([expression]) over ([analytic clause]) function.static @NotNull SQLstatic <T1> @NotNull RecordType<Record>recordType(Collection<? extends Field<?>> fields) RecordType of an arbitrary degree.static <T1> @NotNull RecordType<Record>recordType(Field<?>[] fields) RecordType of an arbitrary degree.static <T1> @NotNull RecordType<Record1<T1>>recordType(Field<T1> field1) RecordType of degree 1.static <T1,
T2> @NotNull RecordType<Record2<T1,T2>> recordType(Field<T1> field1,
Field<T2> field2) RecordType of degree 2.static <T1,
T2,
T3>
@NotNull RecordType<Record3<T1,T2,T3>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3) RecordType of degree 3.static <T1,
T2,
T3,
T4>
@NotNull RecordType<Record4<T1,T2,T3,T4>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4) RecordType of degree 4.static <T1,
T2,
T3,
T4,
T5>
@NotNull RecordType<Record5<T1,T2,T3,T4,T5>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5) RecordType of degree 5.static <T1,
T2,
T3,
T4,
T5,
T6>
@NotNull RecordType<Record6<T1,T2,T3,T4,T5,T6>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6) RecordType of degree 6.static <T1,
T2,
T3,
T4,
T5,
T6,
T7>
@NotNull RecordType<Record7<T1,T2,T3,T4,T5,T6,T7>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7) RecordType of degree 7.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8>
@NotNull RecordType<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8) RecordType of degree 8.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9>
@NotNull RecordType<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9) RecordType of degree 9.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull RecordType<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10) RecordType of degree 10.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull RecordType<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11) RecordType of degree 11.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull RecordType<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12) RecordType of degree 12.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull RecordType<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13) RecordType of degree 13.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull RecordType<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14) RecordType of degree 14.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull RecordType<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15) RecordType of degree 15.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull RecordType<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16) RecordType of degree 16.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull RecordType<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17) RecordType of degree 17.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull RecordType<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18) RecordType of degree 18.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull RecordType<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19) RecordType of degree 19.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull RecordType<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20) RecordType of degree 20.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull RecordType<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21) RecordType of degree 21.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull RecordType<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> recordType(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21,
Field<T22> field22) RecordType of degree 22.regexpReplaceAll(Field<String> field,
String pattern,
String replacement) REGEXP_REPLACE_ALL function.REGEXP_REPLACE_ALL function.regexpReplaceFirst(Field<String> field,
String pattern,
String replacement) REGEXP_REPLACE_FIRST function.REGEXP_REPLACE_FIRST function.static @NotNull AggregateFunction<BigDecimal>REGR_AVGX function.static @NotNull AggregateFunction<BigDecimal>REGR_AVGY function.static @NotNull AggregateFunction<BigDecimal>REGR_COUNT function.static @NotNull AggregateFunction<BigDecimal>regrIntercept(Field<? extends Number> y,
Field<? extends Number> x) REGR_INTERCEPT function.static @NotNull AggregateFunction<BigDecimal>REGR_R2 function.static @NotNull AggregateFunction<BigDecimal>REGR_SLOPE function.static @NotNull AggregateFunction<BigDecimal>REGR_SXX function.static @NotNull AggregateFunction<BigDecimal>REGR_SXY function.static @NotNull AggregateFunction<BigDecimal>REGR_SYY function.static QueryreleaseSavepoint(String name) RELEASE SAVEPOINT statement.static QueryreleaseSavepoint(Name name) RELEASE SAVEPOINT statement.REPEAT function.REPEAT function.static @NotNull RepeatUntilSteprepeat(Collection<? extends Statement> statements) REPEAT loop for use in procedural code.REPEAT function.REPEAT function.static @NotNull RepeatUntilStepREPEAT loop for use in procedural code.REPLACE function.REPLACE function.REPLACE function.REPLACE function.REPLACE function.REPLACE function.static @NotNull ResultQuery<Record>resultQuery(String sql) static @NotNull ResultQuery<Record>resultQuery(String sql,
Object... bindings) static @NotNull ResultQuery<Record>resultQuery(String sql,
QueryPart... parts) static @NotNull ResultQuery<Record>resultQuery(SQL sql) static @NotNull Statementreturn_()RETURN_ function.static @NotNull StatementRETURN_ function.static @NotNull StatementRETURN_ function.REVERSE function.REVERSE function.static RevokeOnSteprevoke(Collection<? extends Privilege> privileges) REVOKE statement.static RevokeOnStepREVOKE statement.static RevokeOnStepREVOKE statement.static RevokeOnSteprevokeGrantOptionFor(Collection<? extends Privilege> privileges) REVOKE GRANT OPTION FOR statement.static RevokeOnSteprevokeGrantOptionFor(Privilege privileges) REVOKE GRANT OPTION FOR statement.static RevokeOnSteprevokeGrantOptionFor(Privilege... privileges) REVOKE GRANT OPTION FOR statement.RIGHT function.RIGHT function.RIGHT function.RIGHT function.static @NotNull Rolestatic @NotNull Rolestatic RollbackToSavepointSteprollback()ROLLBACK statement.static @NotNull GroupFieldstatic @NotNull GroupFieldrollup(FieldOrRow... fields) ROUND function.ROUND function.ROUND function.round(T value) ROUND function.round(T value,
int decimals) ROUND function.ROUND function.static @NotNull RowNN > 22.static @NotNull RowNrow(Collection<?> values) N > 22.static @NotNull RowNrow(SelectField<?>... values) N > 22.static <T1> @NotNull Row1<T1>row(SelectField<T1> field1) 1.static <T1,
T2> @NotNull Row2<T1,T2> row(SelectField<T1> field1,
SelectField<T2> field2) 2.static <T1,
T2,
T3>
@NotNull Row3<T1,T2,T3> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3) 3.static <T1,
T2,
T3,
T4>
@NotNull Row4<T1,T2,T3,T4> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4) 4.static <T1,
T2,
T3,
T4,
T5>
@NotNull Row5<T1,T2,T3,T4,T5> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5) 5.static <T1,
T2,
T3,
T4,
T5,
T6>
@NotNull Row6<T1,T2,T3,T4,T5,T6> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6) 6.static <T1,
T2,
T3,
T4,
T5,
T6,
T7>
@NotNull Row7<T1,T2,T3,T4,T5,T6,T7> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7) 7.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8>
@NotNull Row8<T1,T2,T3,T4,T5,T6,T7,T8> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8) 8.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9>
@NotNull Row9<T1,T2,T3,T4,T5,T6,T7,T8,T9> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9) 9.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull Row10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10) 10.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull Row11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11) 11.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull Row12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12) 12.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull Row13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13) 13.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull Row14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14) 14.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull Row15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15) 15.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull Row16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16) 16.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull Row17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17) 17.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull Row18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18) 18.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull Row19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19) 19.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull Row20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20) 20.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull Row21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20,
SelectField<T21> field21) 21.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> row(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20,
SelectField<T21> field21,
SelectField<T22> field22) 22.static <T1> @NotNull Row1<T1>row(T1 t1) 1.static <T1,
T2> @NotNull Row2<T1,T2> row(T1 t1,
T2 t2) 2.static <T1,
T2,
T3>
@NotNull Row3<T1,T2,T3> row(T1 t1,
T2 t2,
T3 t3) 3.static <T1,
T2,
T3,
T4>
@NotNull Row4<T1,T2,T3,T4> row(T1 t1,
T2 t2,
T3 t3,
T4 t4) 4.static <T1,
T2,
T3,
T4,
T5>
@NotNull Row5<T1,T2,T3,T4,T5> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5) 5.static <T1,
T2,
T3,
T4,
T5,
T6>
@NotNull Row6<T1,T2,T3,T4,T5,T6> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6) 6.static <T1,
T2,
T3,
T4,
T5,
T6,
T7>
@NotNull Row7<T1,T2,T3,T4,T5,T6,T7> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7) 7.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8>
@NotNull Row8<T1,T2,T3,T4,T5,T6,T7,T8> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8) 8.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9>
@NotNull Row9<T1,T2,T3,T4,T5,T6,T7,T8,T9> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9) 9.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull Row10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10) 10.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull Row11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11) 11.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull Row12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11,
T12 t12) 12.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull Row13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11,
T12 t12,
T13 t13) 13.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull Row14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11,
T12 t12,
T13 t13,
T14 t14) 14.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull Row15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11,
T12 t12,
T13 t13,
T14 t14,
T15 t15) 15.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull Row16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11,
T12 t12,
T13 t13,
T14 t14,
T15 t15,
T16 t16) 16.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull Row17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11,
T12 t12,
T13 t13,
T14 t14,
T15 t15,
T16 t16,
T17 t17) 17.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull Row18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11,
T12 t12,
T13 t13,
T14 t14,
T15 t15,
T16 t16,
T17 t17,
T18 t18) 18.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull Row19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11,
T12 t12,
T13 t13,
T14 t14,
T15 t15,
T16 t16,
T17 t17,
T18 t18,
T19 t19) 19.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull Row20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11,
T12 t12,
T13 t13,
T14 t14,
T15 t15,
T16 t16,
T17 t17,
T18 t18,
T19 t19,
T20 t20) 20.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull Row21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11,
T12 t12,
T13 t13,
T14 t14,
T15 t15,
T16 t16,
T17 t17,
T18 t18,
T19 t19,
T20 t20,
T21 t21) 21.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8,
T9 t9,
T10 t10,
T11 t11,
T12 t12,
T13 t13,
T14 t14,
T15 t15,
T16 t16,
T17 t17,
T18 t18,
T19 t19,
T20 t20,
T21 t21,
T22 t22) 22.Row1 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull Field<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> Row10 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull Field<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> Row11 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull Field<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> Row12 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull Field<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> Row13 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull Field<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> Row14 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull Field<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> Row15 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull Field<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> Row16 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull Field<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> Row17 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull Field<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> Row18 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull Field<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> Row19 as a SelectField directly, instead.Row2 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull Field<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> Row20 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull Field<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> Row21 as a SelectField directly, instead.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull Field<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> Row22 as a SelectField directly, instead.Row3 as a SelectField directly, instead.Row4 as a SelectField directly, instead.Row5 as a SelectField directly, instead.Row6 as a SelectField directly, instead.Row7 as a SelectField directly, instead.Row8 as a SelectField directly, instead.Row9 as a SelectField directly, instead.RowN as a SelectField directly, instead.rownum()ROWNUM function.static @NotNull WindowOverStep<Integer>row_number() over ([analytic clause]) function.static @NotNull WindowSpecificationRowsAndStepWindowSpecification with a ROWS clause.static @NotNull WindowSpecificationRowsAndSteprowsBetweenFollowing(int number) WindowSpecification with a ROWS clause.static @NotNull WindowSpecificationRowsAndSteprowsBetweenPreceding(int number) WindowSpecification with a ROWS clause.static @NotNull WindowSpecificationRowsAndStepWindowSpecification with a ROWS clause.static @NotNull WindowSpecificationRowsAndStepWindowSpecification with a ROWS clause.static @NotNull WindowSpecificationExcludeStepWindowSpecification with a ROWS clause.static @NotNull WindowSpecificationExcludeSteprowsFollowing(int number) WindowSpecification with a ROWS clause.ROWS FROM (tables…) expression.static @NotNull WindowSpecificationExcludeSteprowsPreceding(int number) WindowSpecification with a ROWS clause.static @NotNull WindowSpecificationExcludeStepWindowSpecification with a ROWS clause.static @NotNull WindowSpecificationExcludeStepWindowSpecification with a ROWS clause.RPAD function.RPAD function.RPAD function.RPAD function.RPAD function.RPAD function.RTRIM function.RTRIM function.RTRIM function.RTRIM function.RTRIM function.RTRIM function.static QuerySAVEPOINT statement.static QuerySAVEPOINT statement.static @NotNull Schemastatic @NotNull Schemastatic @NotNull SelectSelectStep<Record>select(Collection<? extends SelectFieldOrAsterisk> fields) static <T1> @NotNull SelectSelectStep<Record1<T1>>select(SelectField<T1> field1) static <T1,
T2> @NotNull SelectSelectStep<Record2<T1,T2>> select(SelectField<T1> field1,
SelectField<T2> field2) static <T1,
T2,
T3>
@NotNull SelectSelectStep<Record3<T1,T2,T3>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3) static <T1,
T2,
T3,
T4>
@NotNull SelectSelectStep<Record4<T1,T2,T3,T4>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4) static <T1,
T2,
T3,
T4,
T5>
@NotNull SelectSelectStep<Record5<T1,T2,T3,T4,T5>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5) static <T1,
T2,
T3,
T4,
T5,
T6>
@NotNull SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6) static <T1,
T2,
T3,
T4,
T5,
T6,
T7>
@NotNull SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8>
@NotNull SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9>
@NotNull SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull SelectSelectStep<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull SelectSelectStep<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull SelectSelectStep<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull SelectSelectStep<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull SelectSelectStep<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull SelectSelectStep<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull SelectSelectStep<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull SelectSelectStep<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull SelectSelectStep<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull SelectSelectStep<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull SelectSelectStep<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull SelectSelectStep<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20,
SelectField<T21> field21) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull SelectSelectStep<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> select(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20,
SelectField<T21> field21,
SelectField<T22> field22) static @NotNull SelectSelectStep<Record>select(SelectFieldOrAsterisk... fields) static @NotNull SelectSelectStep<Record1<Integer>>COUNT(*).static @NotNull SelectSelectStep<Record>selectDistinct(Collection<? extends SelectFieldOrAsterisk> fields) static <T1> @NotNull SelectSelectStep<Record1<T1>>selectDistinct(SelectField<T1> field1) static <T1,
T2> @NotNull SelectSelectStep<Record2<T1,T2>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2) static <T1,
T2,
T3>
@NotNull SelectSelectStep<Record3<T1,T2,T3>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3) static <T1,
T2,
T3,
T4>
@NotNull SelectSelectStep<Record4<T1,T2,T3,T4>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4) static <T1,
T2,
T3,
T4,
T5>
@NotNull SelectSelectStep<Record5<T1,T2,T3,T4,T5>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5) static <T1,
T2,
T3,
T4,
T5,
T6>
@NotNull SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6) static <T1,
T2,
T3,
T4,
T5,
T6,
T7>
@NotNull SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8>
@NotNull SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9>
@NotNull SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull SelectSelectStep<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull SelectSelectStep<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull SelectSelectStep<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull SelectSelectStep<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull SelectSelectStep<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull SelectSelectStep<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull SelectSelectStep<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull SelectSelectStep<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull SelectSelectStep<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull SelectSelectStep<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull SelectSelectStep<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull SelectSelectStep<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20,
SelectField<T21> field21) static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull SelectSelectStep<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> selectDistinct(SelectField<T1> field1,
SelectField<T2> field2,
SelectField<T3> field3,
SelectField<T4> field4,
SelectField<T5> field5,
SelectField<T6> field6,
SelectField<T7> field7,
SelectField<T8> field8,
SelectField<T9> field9,
SelectField<T10> field10,
SelectField<T11> field11,
SelectField<T12> field12,
SelectField<T13> field13,
SelectField<T14> field14,
SelectField<T15> field15,
SelectField<T16> field16,
SelectField<T17> field17,
SelectField<T18> field18,
SelectField<T19> field19,
SelectField<T20> field20,
SelectField<T21> field21,
SelectField<T22> field22) static @NotNull SelectSelectStep<Record>selectDistinct(SelectFieldOrAsterisk... fields) static @NotNull SelectWhereStep<Record>selectFrom(String sql) *.static @NotNull SelectWhereStep<Record>selectFrom(String sql,
Object... bindings) *.static @NotNull SelectWhereStep<Record>selectFrom(String sql,
QueryPart... parts) *.static @NotNull SelectWhereStep<Record>selectFrom(Name table) *.static @NotNull SelectWhereStep<Record>selectFrom(SQL sql) *.static <R extends Record>
@NotNull SelectWhereStep<R>selectFrom(TableLike<R> table) static @NotNull SelectSelectStep<Record1<Integer>>1
literal.static @NotNull SelectSelectStep<Record1<Integer>>0
literal.static @NotNull Sequence<BigInteger>sequence(Name) instead.sequence(Name, Class)
instead.sequence(Name, DataType)
instead.static @NotNull Sequence<BigInteger>static RowCountQuerySET statement.static RowCountQuerySET statement.static RowCountQuerysetCatalog(String catalog) SET CATALOG statement.static RowCountQuerysetCatalog(Catalog catalog) SET CATALOG statement.static RowCountQuerysetCatalog(Name catalog) SET CATALOG statement.static RowCountQuerySET LOCAL statement.static RowCountQuerySET LOCAL statement.static RowCountQuerySET SCHEMA statement.static RowCountQuerySET SCHEMA statement.static RowCountQuerySET SCHEMA statement.SHL function.SHL function.SHL function.SHL function.SHR function.SHR function.SHR function.SHR function.SIGN function.SIGN function.static SignalSetStepsignalSQLState(Object value) SIGNAL_SQLSTATE function.static SignalSetStepsignalSQLState(Field<?> value) SIGNAL_SQLSTATE function.static @NotNull Field<BigDecimal>SIN function.static @NotNull Field<BigDecimal>SIN function.static @NotNull Field<BigDecimal>SINH function.static @NotNull Field<BigDecimal>SINH function.SPACE function.SPACE function.SPLIT_PART function.SPLIT_PART function.SPLIT_PART function.SPLIT_PART function.static @NotNull SQLstatic @NotNull SQLstatic @NotNull SQLstatic @NotNull Field<BigDecimal>SQRT function.static @NotNull Field<BigDecimal>SQRT function.SQUARE function.square(T value) SQUARE function.ST_AREA function.ST_AREA function.static QuerySTART TRANSACTION statement.static @NotNull Field<byte[]>stAsBinary(Field<? extends Spatial> value) ST_ASBINARY function.static @NotNull Field<byte[]>stAsBinary(Spatial value) ST_ASBINARY function.ST_ASTEXT function.ST_ASTEXT function.static @NotNull Statementstatic @NotNull Statementstatic @NotNull Statementstatic @NotNull Statementstatic @NotNull Blockstatements(Collection<? extends Statement> statements) BEGIN … END;, unless explicitly needed.static @NotNull Blockstatements(Statement... statements) BEGIN … END;, unless explicitly needed.stCentroid(Field<Geometry> value) ST_CENTROID function.stCentroid(Geometry value) ST_CENTROID function.stContains(Field<T> arg1,
Field<T> arg2) ST_CONTAINS function.stContains(Field<T> arg1,
T arg2) ST_CONTAINS function.stContains(T arg1,
Field<T> arg2) ST_CONTAINS function.stContains(T arg1,
T arg2) ST_CONTAINS function.static @NotNull ConditionST_CROSSES function.static @NotNull ConditionST_CROSSES function.static @NotNull ConditionST_CROSSES function.static @NotNull ConditionST_CROSSES function.static @NotNull AggregateFunction<BigDecimal>STDDEV_POP function.static @NotNull AggregateFunction<BigDecimal>stddevSamp(Field<? extends Number> field) STDDEV_SAMP function.stDifference(Field<T> arg1,
Field<T> arg2) ST_DIFFERENCE function.stDifference(Field<T> arg1,
T arg2) ST_DIFFERENCE function.stDifference(T arg1,
Field<T> arg2) ST_DIFFERENCE function.stDifference(T arg1,
T arg2) ST_DIFFERENCE function.stDisjoint(Field<T> arg1,
Field<T> arg2) ST_DISJOINT function.stDisjoint(Field<T> arg1,
T arg2) ST_DISJOINT function.stDisjoint(T arg1,
Field<T> arg2) ST_DISJOINT function.stDisjoint(T arg1,
T arg2) ST_DISJOINT function.stDistance(Field<T> arg1,
Field<T> arg2) ST_DISTANCE function.stDistance(Field<T> arg1,
T arg2) ST_DISTANCE function.stDistance(T arg1,
Field<T> arg2) ST_DISTANCE function.stDistance(T arg1,
T arg2) ST_DISTANCE function.stEndPoint(Field<T> value) ST_ENDPOINT function.stEndPoint(T value) ST_ENDPOINT function.ST_EQUALS function.ST_EQUALS function.ST_EQUALS function.stEquals(T arg1,
T arg2) ST_EQUALS function.stExteriorRing(Field<Geometry> value) ST_EXTERIORRING function.stExteriorRing(Geometry value) ST_EXTERIORRING function.stGeometryN(Field<T> value,
int position) ST_GEOMETRYN function.stGeometryN(Field<T> value,
Field<? extends Number> position) ST_GEOMETRYN function.stGeometryN(T value,
int position) ST_GEOMETRYN function.stGeometryN(T value,
Field<? extends Number> position) ST_GEOMETRYN function.stGeometryType(Field<? extends Spatial> value) ST_GEOMETRYTYPE function.stGeometryType(Spatial value) ST_GEOMETRYTYPE function.stGeomFromText(String text) ST_GEOMFROMTEXT function.stGeomFromText(String text,
int srid) ST_GEOMFROMTEXT function.stGeomFromText(String text,
Field<? extends Number> srid) ST_GEOMFROMTEXT function.stGeomFromText(Field<String> text) ST_GEOMFROMTEXT function.stGeomFromText(Field<String> text,
int srid) ST_GEOMFROMTEXT function.stGeomFromText(Field<String> text,
Field<? extends Number> srid) ST_GEOMFROMTEXT function.stGeomFromWKB(byte[] wkb) ST_GEOMFROMWKB function.stGeomFromWKB(byte[] wkb,
int srid) ST_GEOMFROMWKB function.stGeomFromWKB(byte[] wkb,
Field<? extends Number> srid) ST_GEOMFROMWKB function.stGeomFromWKB(Field<byte[]> wkb) ST_GEOMFROMWKB function.stGeomFromWKB(Field<byte[]> wkb,
int srid) ST_GEOMFROMWKB function.stGeomFromWKB(Field<byte[]> wkb,
Field<? extends Number> srid) ST_GEOMFROMWKB function.stInteriorRingN(Field<Geometry> value,
int position) ST_INTERIORRINGN function.stInteriorRingN(Field<Geometry> value,
Field<? extends Number> position) ST_INTERIORRINGN function.stInteriorRingN(Geometry value,
int position) ST_INTERIORRINGN function.stInteriorRingN(Geometry value,
Field<? extends Number> position) ST_INTERIORRINGN function.stIntersection(Field<T> arg1,
Field<T> arg2) ST_INTERSECTION function.stIntersection(Field<T> arg1,
T arg2) ST_INTERSECTION function.stIntersection(T arg1,
Field<T> arg2) ST_INTERSECTION function.stIntersection(T arg1,
T arg2) ST_INTERSECTION function.stIntersects(Field<T> arg1,
Field<T> arg2) ST_INTERSECTS function.stIntersects(Field<T> arg1,
T arg2) ST_INTERSECTS function.stIntersects(T arg1,
Field<T> arg2) ST_INTERSECTS function.stIntersects(T arg1,
T arg2) ST_INTERSECTS function.static @NotNull ConditionstIsClosed(Field<? extends Spatial> value) ST_ISCLOSED function.static @NotNull ConditionstIsClosed(Spatial value) ST_ISCLOSED function.static @NotNull ConditionST_ISEMPTY function.static @NotNull ConditionST_ISEMPTY function.ST_LENGTH function.ST_LENGTH function.stNumGeometries(Field<? extends Spatial> value) ST_NUMGEOMETRIES function.stNumGeometries(Spatial value) ST_NUMGEOMETRIES function.stNumInteriorRings(Field<Geometry> value) ST_NUMINTERIORRING function.stNumInteriorRings(Geometry value) ST_NUMINTERIORRING function.stNumPoints(Field<? extends Spatial> value) ST_NUMPOINTS function.stNumPoints(Spatial value) ST_NUMPOINTS function.stOverlaps(Field<T> arg1,
Field<T> arg2) ST_OVERLAPS function.stOverlaps(Field<T> arg1,
T arg2) ST_OVERLAPS function.stOverlaps(T arg1,
Field<T> arg2) ST_OVERLAPS function.stOverlaps(T arg1,
T arg2) ST_OVERLAPS function.ST_POINTN function.ST_POINTN function.stPointN(T value,
int position) ST_POINTN function.ST_POINTN function.ST_SRID function.ST_SRID function.stStartPoint(Field<T> value) ST_STARTPOINT function.stStartPoint(T value) ST_STARTPOINT function.ST_TOUCHES function.ST_TOUCHES function.ST_TOUCHES function.stTouches(T arg1,
T arg2) ST_TOUCHES function.ST_UNION function.ST_UNION function.ST_UNION function.stUnion(T arg1,
T arg2) ST_UNION function.ST_WITHIN function.ST_WITHIN function.ST_WITHIN function.stWithin(T arg1,
T arg2) ST_WITHIN function.ST_X function.ST_X function.ST_Y function.ST_Y function.ST_Z function.ST_Z function.SUBSTRING function.SUBSTRING function.SUBSTRING function.SUBSTRING function.SUBSTRING function.substring(Field<String> string,
Field<? extends Number> startingPosition,
Field<? extends Number> length) SUBSTRING function.substringIndex(Field<String> string,
String delimiter,
int n) SUBSTRING_INDEX function.SUBSTRING_INDEX function.substringIndex(Field<String> string,
Field<String> delimiter,
int n) SUBSTRING_INDEX function.SUBSTRING_INDEX function.static @NotNull AggregateFunction<BigDecimal>SUM function.static @NotNull AggregateFunction<BigDecimal>sumDistinct(Field<? extends Number> field) SUM_DISTINCT function.sysConnectByPath(Field<?> field,
String separator) SYS_CONNECT_BY_PATH function.static @NotNull NamesystemName(String unqualifiedName) static @NotNull NamesystemName(String... qualifiedName) static @NotNull NamesystemName(Collection<String> qualifiedName) SYSTEM_TIME Period reference.static <T> @NotNull Period<T>systemTime(Class<T> type) SYSTEM_TIME Period reference.static <T> @NotNull Period<T>systemTime(DataType<T> type) SYSTEM_TIME Period reference.static @NotNull Table<?>unnest(Object[]).static @NotNull Table<?>table(Collection<?> list) unnest(Collection).static @NotNull Table<?>table(ArrayRecord<?> array) unnest(ArrayRecord).static @NotNull Table<?>unnest(Field).Table that can be used
in SQL statements through values(RowN...).TableLike.asTable(), which might look a bit more fluent
like this, to some users.table(R record) table(R... records) static @NotNull Field<BigDecimal>TAN function.static @NotNull Field<BigDecimal>TAN function.static @NotNull Field<BigDecimal>TANH function.static @NotNull Field<BigDecimal>TANH function.static @NotNull Field<BigDecimal>tau()TAU function.TIME.TIME.TIME.TIMESTAMP.TIMESTAMP.TIMESTAMP.timestampAdd(Timestamp date,
Number interval) TIMESTAMP_ADD function.timestampAdd(Timestamp date,
Number interval,
DatePart datePart) TIMESTAMP_ADD function.timestampAdd(Timestamp date,
Field<? extends Number> interval) TIMESTAMP_ADD function.timestampAdd(Timestamp date,
Field<? extends Number> interval,
DatePart datePart) TIMESTAMP_ADD function.timestampAdd(Field<Timestamp> date,
Number interval) TIMESTAMP_ADD function.timestampAdd(Field<Timestamp> date,
Number interval,
DatePart datePart) TIMESTAMP_ADD function.timestampAdd(Field<Timestamp> date,
Field<? extends Number> interval) TIMESTAMP_ADD function.TIMESTAMP_ADD function.static @NotNull Field<DayToSecond>timestampDiff(Timestamp timestamp1,
Timestamp timestamp2) INTERVAL DAY TO SECOND
type.static @NotNull Field<DayToSecond>timestampDiff(Timestamp timestamp1,
Field<Timestamp> timestamp2) INTERVAL DAY TO SECOND
type.timestampDiff(DatePart part,
Timestamp startDate,
Timestamp endDate) endDate - startDate in terms
of part.timestampDiff(DatePart part,
Timestamp startDate,
Field<Timestamp> endDate) endDate - startDate in terms
of part.timestampDiff(DatePart part,
Field<Timestamp> startDate,
Timestamp endDate) endDate - startDate in terms
of part.endDate - startDate in terms
of part.static @NotNull Field<DayToSecond>timestampDiff(Field<Timestamp> timestamp1,
Timestamp timestamp2) INTERVAL DAY TO SECOND
type.static @NotNull Field<DayToSecond>timestampDiff(Field<Timestamp> timestamp1,
Field<Timestamp> timestamp2) INTERVAL DAY TO SECOND
type.timestampSub(Timestamp timestamp,
Number interval) timestampSub(Timestamp date,
Number interval,
DatePart datePart) timestampSub(Timestamp date,
Field<? extends Number> interval,
DatePart datePart) timestampSub(Field<Timestamp> date,
Number interval,
DatePart datePart) timestampSub(Field<Timestamp> timestamp,
Field<? extends Number> interval) timezoneHour(Temporal value) timezoneHour(Date value) timezoneHour(Field<?> field) timezoneMinute(Temporal value) timezoneMinute(Date value) timezoneMinute(Field<?> field) TO_CHAR function.TO_CHAR function.TO_CHAR function.TO_CHAR function.TO_CHAR function.TO_CHAR function.TO_DATE function.TO_DATE function.TO_DATE function.TO_DATE function.TO_HEX function.TO_HEX function.toLocalDate(String value,
String format) DATE.toLocalDate(String value,
Field<String> format) DATE.toLocalDate(Field<String> value,
String format) DATE.toLocalDate(Field<String> value,
Field<String> format) DATE.static @NotNull Field<LocalDateTime>toLocalDateTime(String value,
String format) TIMESTAMP.static @NotNull Field<LocalDateTime>toLocalDateTime(String value,
Field<String> format) TIMESTAMP.static @NotNull Field<LocalDateTime>toLocalDateTime(Field<String> value,
String format) TIMESTAMP.static @NotNull Field<LocalDateTime>toLocalDateTime(Field<String> value,
Field<String> format) TIMESTAMP.toTimestamp(String value,
String formatMask) TO_TIMESTAMP function.toTimestamp(String value,
Field<String> formatMask) TO_TIMESTAMP function.toTimestamp(Field<String> value,
String formatMask) TO_TIMESTAMP function.toTimestamp(Field<String> value,
Field<String> formatMask) TO_TIMESTAMP function.TRANSLATE function.TRANSLATE function.TRANSLATE function.TRANSLATE function.static @NotNull Triggerstatic @NotNull TriggerTRIM function.TRIM function.TRIM function.TRIM function.TRIM function.TRIM function.static @NotNull TrueCondition that will always evaluate to
TRUE.static @NotNull Field<LocalDateTime>trunc(LocalDateTime timestamp) static @NotNull Field<LocalDateTime>trunc(LocalDateTime timestamp,
DatePart part) static <T> @NotNull Field<T>TRUNC function.static <T> @NotNull Field<T>TRUNC function.trunc(T number) trunc(T value,
int decimals) TRUNC function.TRUNC function.static TruncateIdentityStep<Record>TRUNCATE statement.static TruncateIdentityStep<Record>TRUNCATE statement.static TruncateIdentityStep<Record>truncate(Collection<? extends Table<?>> table) TRUNCATE statement.static TruncateIdentityStep<Record>TRUNCATE statement.static TruncateIdentityStep<Record>TRUNCATE statement.static TruncateIdentityStep<Record>TRUNCATE statement.static <R extends Record>
TruncateIdentityStep<R>TRUNCATE statement.static TruncateIdentityStep<Record>truncateTable(String table) TRUNCATE TABLE statement.static TruncateIdentityStep<Record>truncateTable(String... table) TRUNCATE TABLE statement.static TruncateIdentityStep<Record>truncateTable(Collection<? extends Table<?>> table) TRUNCATE TABLE statement.static TruncateIdentityStep<Record>truncateTable(Name table) TRUNCATE TABLE statement.static TruncateIdentityStep<Record>truncateTable(Name... table) TRUNCATE TABLE statement.static TruncateIdentityStep<Record>truncateTable(Table<?>... table) TRUNCATE TABLE statement.static <R extends Record>
TruncateIdentityStep<R>truncateTable(Table<R> table) TRUNCATE TABLE statement.static <T> @NotNull Field<T>TRY_CAST function.static <T> @NotNull Field<T>TRY_CAST function.two()2 literal.static @NotNull Type<?>static <T> @NotNull Type<T>static @NotNull Type<?>static <T> @NotNull Type<T>static @NotNull ConstraintEnforcementStepUNIQUE constraint.static @NotNull ConstraintEnforcementStepunique(Collection<? extends Field<?>> fields) UNIQUE constraint.static @NotNull ConstraintEnforcementStepUNIQUE constraint.static @NotNull ConstraintEnforcementStepUNIQUE constraint.static @NotNull ConditionUNIQUE function.static @NotNull Table<?>static @NotNull Table<?>unnest(Collection<?> list) static @NotNull Table<?>unnest(ArrayRecord<?> array) static @NotNull Table<?>static @NotNull NameunquotedName(String unqualifiedName) static @NotNull NameunquotedName(String... qualifiedName) static @NotNull NameunquotedName(Collection<String> qualifiedName) static <R extends Record>
@NotNull UpdateSetFirstStep<R>static @NotNull Conditionupdating()UPDATING function.UPPER function.UPPER function.static @NotNull Userstatic @NotNull Userstatic @NotNull DSLContextusing(io.r2dbc.spi.Connection connection) static @NotNull DSLContextusing(io.r2dbc.spi.ConnectionFactory connectionFactory) static @NotNull DSLContextusing(io.r2dbc.spi.ConnectionFactory connectionFactory,
SQLDialect dialect) static @NotNull DSLContextusing(io.r2dbc.spi.ConnectionFactory connectionFactory,
SQLDialect dialect,
Settings settings) static @NotNull DSLContextusing(io.r2dbc.spi.Connection connection,
SQLDialect dialect) static @NotNull DSLContextusing(io.r2dbc.spi.Connection connection,
SQLDialect dialect,
Settings settings) static @NotNull CloseableDSLContextstatic @NotNull CloseableDSLContextstatic @NotNull CloseableDSLContextusing(String url,
Properties properties) static @NotNull DSLContextusing(Connection connection) static @NotNull DSLContextusing(Connection connection,
Settings settings) static @NotNull DSLContextusing(Connection connection,
SQLDialect dialect) static @NotNull DSLContextusing(Connection connection,
SQLDialect dialect,
Settings settings) static @NotNull DSLContextusing(DataSource datasource,
SQLDialect dialect) static @NotNull DSLContextusing(DataSource datasource,
SQLDialect dialect,
Settings settings) static @NotNull DSLContextusing(Configuration configuration) static @NotNull DSLContextusing(ConnectionProvider connectionProvider,
SQLDialect dialect) static @NotNull DSLContextusing(ConnectionProvider connectionProvider,
SQLDialect dialect,
Settings settings) static @NotNull DSLContextusing(SQLDialect dialect) static @NotNull DSLContextusing(SQLDialect dialect,
Settings settings) uuid()UUID function.val(boolean value) val(byte value) static @NotNull Param<byte[]>val(byte[] value) val(double value) val(float value) val(int value) val(long value) val(short value) static <T> @NotNull Param<T>static <T> @NotNull Param<T>static <T> @NotNull Param<T>static @NotNull Param<BigDecimal>val(BigDecimal value) static @NotNull Param<BigInteger>val(BigInteger value) static @NotNull Param<LocalDateTime>val(LocalDateTime value) static @NotNull Param<OffsetDateTime>val(OffsetDateTime value) static @NotNull Param<OffsetTime>val(OffsetTime value) static <T> @NotNull Param<T>val(T value) value(boolean value) val(boolean) to be used in Scala and Groovy, where
val is a reserved keyword.value(byte value) val(byte) to be used in Scala and Groovy, where
val is a reserved keyword.static @NotNull Param<byte[]>value(byte[] value) val(byte[]) to be used in Scala and Groovy, where
val is a reserved keyword.value(double value) val(double) to be used in Scala and Groovy, where
val is a reserved keyword.value(float value) val(float) to be used in Scala and Groovy, where
val is a reserved keyword.value(int value) val(int) to be used in Scala and Groovy, where
val is a reserved keyword.value(long value) val(long) to be used in Scala and Groovy, where
val is a reserved keyword.value(short value) val(short) to be used in Scala and Groovy, where
val is a reserved keyword.val(Boolean) to be used in Scala and Groovy, where
val is a reserved keyword.val(Byte) to be used in Scala and Groovy, where
val is a reserved keyword.static <T> @NotNull Field<T>VALUE pseudo field for usage with
DOMAIN specifications.val(Double) to be used in Scala and Groovy, where
val is a reserved keyword.val(Float) to be used in Scala and Groovy, where
val is a reserved keyword.val(Integer) to be used in Scala and Groovy, where
val is a reserved keyword.val(Long) to be used in Scala and Groovy, where
val is a reserved keyword.static <T> @NotNull Param<T>val(Object, Class) to be used in Scala and Groovy,
where val is a reserved keyword.static <T> @NotNull Param<T>val(Object, DataType) to be used in Scala and Groovy, where
val is a reserved keyword.static <T> @NotNull Param<T>val(Object, Field) to be used in Scala and Groovy, where
val is a reserved keyword.val(Short) to be used in Scala and Groovy, where
val is a reserved keyword.val(String) to be used in Scala and Groovy, where
val is a reserved keyword.static @NotNull Param<BigDecimal>value(BigDecimal value) val(BigDecimal) to be used in Scala and Groovy, where
val is a reserved keyword.static @NotNull Param<BigInteger>value(BigInteger value) val(BigInteger) to be used in Scala and Groovy, where
val is a reserved keyword.val(Date) to be used in Scala and Groovy, where
val is a reserved keyword.val(Time) to be used in Scala and Groovy, where
val is a reserved keyword.val(Timestamp) to be used in Scala and Groovy, where
val is a reserved keyword.val(Instant) to be used in Scala and Groovy, where
val is a reserved keyword.val(LocalDate) to be used in Scala and Groovy, where
val is a reserved keyword.static @NotNull Param<LocalDateTime>value(LocalDateTime value) val(LocalDateTime) to be used in Scala and Groovy, where
val is a reserved keyword.val(LocalTime) to be used in Scala and Groovy, where
val is a reserved keyword.static @NotNull Param<OffsetDateTime>value(OffsetDateTime value) val(OffsetDateTime) to be used in Scala and Groovy, where
val is a reserved keyword.static @NotNull Param<OffsetTime>value(OffsetTime value) val(OffsetTime) to be used in Scala and Groovy, where
val is a reserved keyword.val(UUID) to be used in Scala and Groovy, where
val is a reserved keyword.static <T> @NotNull Field<T>VALUE pseudo field for usage with
DOMAIN specifications.val(Geography) to be used in Scala and Groovy, where
val is a reserved keyword.val(Geometry) to be used in Scala and Groovy, where
val is a reserved keyword.val(JSON) to be used in Scala and Groovy, where
val is a reserved keyword.val(JSONB) to be used in Scala and Groovy, where
val is a reserved keyword.val(UByte) to be used in Scala and Groovy, where
val is a reserved keyword.val(UInteger) to be used in Scala and Groovy, where
val is a reserved keyword.val(ULong) to be used in Scala and Groovy, where
val is a reserved keyword.val(UShort) to be used in Scala and Groovy, where
val is a reserved keyword.val(XML) to be used in Scala and Groovy, where
val is a reserved keyword.static <T> @NotNull Param<T>value(T value) val(Object) to be used in Scala and Groovy, where
val is a reserved keyword.VALUES() expression of degree 1.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull Table<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> VALUES() expression of degree 10.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull Table<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> VALUES() expression of degree 11.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull Table<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> VALUES() expression of degree 12.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull Table<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> VALUES() expression of degree 13.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull Table<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> VALUES() expression of degree 14.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull Table<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> VALUES() expression of degree 15.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull Table<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> VALUES() expression of degree 16.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull Table<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> VALUES() expression of degree 17.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull Table<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> VALUES() expression of degree 18.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull Table<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> VALUES() expression of degree 19.VALUES() expression of degree 2.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull Table<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> VALUES() expression of degree 20.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull Table<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> VALUES() expression of degree 21.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull Table<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> values(Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>... rows) VALUES() expression of degree 22.VALUES() expression of degree 3.VALUES() expression of degree 4.VALUES() expression of degree 5.VALUES() expression of degree 6.VALUES() expression of degree 7.VALUES() expression of degree 8.VALUES() expression of degree 9.VALUES() expression of arbitrary degree.static <T> @NotNull Variable<T>static <T> @NotNull Variable<T>static <T> @NotNull Variable<T>var(Name, DataType) to be used in Scala and
Groovy, where var is a reserved keyword.static <T> @NotNull Variable<T>var(Name, DataType) to be used in Scala and
Groovy, where var is a reserved keyword.static @NotNull AggregateFunction<BigDecimal>VAR_POP function.static @NotNull AggregateFunction<BigDecimal>VAR_SAMP function.static <T> @NotNull CaseConditionStep<T>Case statement.static <T> @NotNull CaseConditionStep<T>Case statement.static <T> @NotNull CaseConditionStep<T>Case statement.static <T> @NotNull CaseConditionStep<T>Case statement.static <T> @NotNull CaseConditionStep<T>Case statement.static <T> @NotNull CaseConditionStep<T>Case statement.static @NotNull LoopStepWHILE loop for use in procedural code.WIDTH_BUCKET function.widthBucket(Field<T> field,
T low,
T high,
int buckets) WIDTH_BUCKET function.static @NotNull WithAsStepWITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep1WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepWITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep2WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep3WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep4WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep5with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep6with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep7with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep8with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep9with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep10with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep11with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep12with(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep13with(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep14with(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep15with(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep16with(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep17with(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep18with(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep19with(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep20with(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep21with(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep22with(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepwith(String alias,
Collection<String> fieldAliases) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepstatic @NotNull WithStepwith(Collection<? extends CommonTableExpression<?>> tables) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithStepwith(CommonTableExpression<?>... tables) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepWITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepwith(Name alias,
Collection<? extends Name> fieldAliases) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep1WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepWITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep2WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep3WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep4WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep5with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep6with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep7with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep8with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep9with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep10with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep11with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep12with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep13with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep14with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep15with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep16with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep17with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep18with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17,
Name fieldAlias18) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep19with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17,
Name fieldAlias18,
Name fieldAlias19) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep20with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17,
Name fieldAlias18,
Name fieldAlias19,
Name fieldAlias20) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep21with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17,
Name fieldAlias18,
Name fieldAlias19,
Name fieldAlias20,
Name fieldAlias21) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep22with(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17,
Name fieldAlias18,
Name fieldAlias19,
Name fieldAlias20,
Name fieldAlias21,
Name fieldAlias22) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepwithRecursive(String alias) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep1withRecursive(String alias,
String fieldAlias1) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepwithRecursive(String alias,
String... fieldAliases) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep2withRecursive(String alias,
String fieldAlias1,
String fieldAlias2) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep3withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep4withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep5withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep6withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep7withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep8withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep9withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep10withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep11withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep12withRecursive(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep13withRecursive(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep14withRecursive(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep15withRecursive(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep16withRecursive(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep17withRecursive(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep18withRecursive(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep19withRecursive(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep20withRecursive(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep21withRecursive(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep22withRecursive(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) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepwithRecursive(String alias,
Collection<String> fieldAliases) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepwithRecursive(String alias,
Function<? super Field<?>,? extends String> fieldNameFunction) static @NotNull WithStepwithRecursive(Collection<? extends CommonTableExpression<?>> tables) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithStepwithRecursive(CommonTableExpression<?>... tables) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepwithRecursive(Name alias) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepwithRecursive(Name alias,
Collection<? extends Name> fieldAliases) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep1withRecursive(Name alias,
Name fieldAlias1) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStepwithRecursive(Name alias,
Name... fieldAliases) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep2withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep3withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep4WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep5withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep6withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep7withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep8withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep9withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep10withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep11withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep12withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep13withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep14withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep15withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep16withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep17withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep18withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17,
Name fieldAlias18) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep19withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17,
Name fieldAlias18,
Name fieldAlias19) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep20withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17,
Name fieldAlias18,
Name fieldAlias19,
Name fieldAlias20) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep21withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17,
Name fieldAlias18,
Name fieldAlias19,
Name fieldAlias20,
Name fieldAlias21) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull WithAsStep22withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3,
Name fieldAlias4,
Name fieldAlias5,
Name fieldAlias6,
Name fieldAlias7,
Name fieldAlias8,
Name fieldAlias9,
Name fieldAlias10,
Name fieldAlias11,
Name fieldAlias12,
Name fieldAlias13,
Name fieldAlias14,
Name fieldAlias15,
Name fieldAlias16,
Name fieldAlias17,
Name fieldAlias18,
Name fieldAlias19,
Name fieldAlias20,
Name fieldAlias21,
Name fieldAlias22) WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.static @NotNull XMLAggOrderByStep<XML>static @NotNull XMLAttributesxmlattributes(Collection<? extends Field<?>> attributes) static @NotNull XMLAttributesxmlattributes(Field<?>... attributes) xmlcomment(String comment) XMLCOMMENT function.xmlcomment(Field<String> comment) XMLCOMMENT function.xmlconcat(Collection<? extends Field<?>> args) XMLCONCAT function.XMLCONCAT function.xmldocument(Field<XML> content) XMLDOCUMENT function.xmlelement(String name,
Collection<? extends Field<?>> content) xmlelement(String name,
Field<?>... content) xmlelement(String name,
XMLAttributes attributes,
Collection<? extends Field<?>> content) xmlelement(String name,
XMLAttributes attributes,
Field<?>... content) xmlelement(Name name,
Collection<? extends Field<?>> content) xmlelement(Name name,
Field<?>... content) xmlelement(Name name,
XMLAttributes attributes,
Collection<? extends Field<?>> content) xmlelement(Name name,
XMLAttributes attributes,
Field<?>... content) static @NotNull XMLExistsPassingStepstatic @NotNull XMLExistsPassingStepxmlforest(Collection<? extends Field<?>> fields) XMLFOREST function.XMLFOREST function.xmlparseContent(String content) xmlparseContent(Field<String> content) xmlparseDocument(String content) xmlparseDocument(Field<String> content) XMLPI function.XMLPI function.XMLPI function.XMLPI function.static @NotNull XMLQueryPassingStepstatic @NotNull XMLQueryPassingStepstatic <T> @NotNull Field<T>xmlserializeContent(Field<XML> value,
DataType<T> type) XMLSERIALIZE_CONTENT function.static <T> @NotNull Field<T>xmlserializeContent(XML value,
DataType<T> type) XMLSERIALIZE_CONTENT function.static <T> @NotNull Field<T>xmlserializeDocument(Field<XML> value,
DataType<T> type) XMLSERIALIZE function.static <T> @NotNull Field<T>xmlserializeDocument(XML value,
DataType<T> type) XMLSERIALIZE function.static @NotNull XMLTablePassingStepstatic @NotNull XMLTablePassingStepstatic @NotNull Conditionxor(Collection<? extends Condition> conditions) static @NotNull Conditionstatic @NotNull Conditionzero()0 literal.Without a connection or data source, this executor cannot execute queries. Use it to render SQL only.
dialect - The dialect to use with objects created from this executorWithout a connection or data source, this executor cannot execute queries. Use it to render SQL only.
dialect - The dialect to use with objects created from this executorsettings - The runtime settings to apply to objects created from
this executor
Clients must ensure connections are closed properly by calling
CloseableDSLContext.close() on the resulting DSLContext.
For example:
// Auto-closing DSLContext instance to free resources
try (CloseableDSLContext ctx = DSL.using("jdbc:h2:~/test")) {
// ...
}
Both acquisition and release of JDBC and R2DBC connection URLs are blocking.
url - The connection URL.
Clients must ensure connections are closed properly by calling
CloseableDSLContext.close() on the resulting DSLContext.
For example:
// Auto-closing DSLContext instance to free resources
try (CloseableDSLContext ctx = DSL.using("jdbc:h2:~/test", "sa", "")) {
// ...
}
Both acquisition and release of JDBC and R2DBC connection URLs are blocking.
url - The connection URL.username - The connection user name.password - The connection password.
Clients must ensure connections are closed properly by calling
CloseableDSLContext.close() on the resulting DSLContext.
For example:
// Auto-closing DSLContext instance to free resources
try (CloseableDSLContext ctx = DSL.using("jdbc:h2:~/test", properties)) {
// ...
}
Both acquisition and release of JDBC and R2DBC connection URLs are blocking.
url - The connection URL.properties - The connection 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
using(Connection, Settings), guessing the SQLDialect
using JDBCUtils.dialect(Connection)
connection - The connection to use with objects created from this
executorIf you provide a JDBC connection to a jOOQ Configuration, jOOQ will use that connection directly for creating statements.
This is a convenience constructor for
using(ConnectionProvider, SQLDialect, Settings) using a
DefaultConnectionProvider
connection - The connection to use with objects created from this
executordialect - The dialect to use with objects created from this executorIf you provide a JDBC connection to a jOOQ Configuration, jOOQ will use that connection directly for creating statements.
This is a convenience constructor for
using(ConnectionProvider, SQLDialect, Settings) using a
DefaultConnectionProvider and guessing the SQLDialect
using JDBCUtils.dialect(Connection)
connection - The connection to use with objects created from this
executorsettings - The runtime settings to apply to objects created from
this executorIf you provide a JDBC connection to a jOOQ Configuration, jOOQ will use that connection directly for creating statements.
This is a convenience constructor for
using(ConnectionProvider, SQLDialect, Settings) using a
DefaultConnectionProvider
connection - The connection to use with objects created from this
executordialect - The dialect to use with objects created from this executorsettings - The runtime settings to apply to objects created from
this executorIf 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
using(ConnectionProvider, SQLDialect) using a
DataSourceConnectionProvider
datasource - The data source to use with objects created from this
executordialect - The dialect to use with objects created from this executorIf 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
using(ConnectionProvider, SQLDialect, Settings) using a
DataSourceConnectionProvider
datasource - The data source to use with objects created from this
executordialect - The dialect to use with objects created from this executorsettings - The runtime settings to apply to objects created from
this executorconnectionProvider - The connection provider providing jOOQ with
JDBC connectionsdialect - The dialect to use with objects created from this executorconnectionProvider - The connection provider providing jOOQ with
JDBC connectionsdialect - The dialect to use with objects created from this executorsettings - The runtime settings to apply to objects created from
this executorconnectionFactory - The R2DBC connection factory providing jOOQ with
R2DBC connectionsconnectionFactory - The R2DBC connection factory providing jOOQ with
R2DBC connectionsdialect - The dialect to use with objects created from this executorconnectionFactory - The R2DBC connection factory providing jOOQ with
R2DBC connectionsdialect - The dialect to use with objects created from this executorsettings - The runtime settings to apply to objects created from
this executorconnection - The R2DBC connectionconnection - The R2DBC connectiondialect - The dialect to use with objects created from this executorconnection - The R2DBC connectiondialect - The dialect to use with objects created from this executorsettings - The runtime settings to apply to objects created from
this executorconfiguration - The configurationWITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String) for strictly non-recursive CTE
and withRecursive(String) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(Name) for strictly non-recursive CTE
and withRecursive(Name) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(Name, Name...) for strictly non-recursive CTE
and withRecursive(Name, Name...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(Name, Name...) for strictly non-recursive CTE
and withRecursive(Name, Name...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE and
withRecursive(String, String...) for strictly recursive CTE.
This works in a similar way as with(String, String...), except
that all column names are produced by a function that receives the CTE's
Select columns as input.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
Reusable CommonTableExpression types can be constructed through
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
with(CommonTableExpression...) for strictly non-recursive CTE
and withRecursive(CommonTableExpression...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
Reusable CommonTableExpression types can be constructed through
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
with(CommonTableExpression...) for strictly non-recursive CTE
and withRecursive(CommonTableExpression...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String) for strictly non-recursive CTE
and withRecursive(String) for strictly
recursive CTE.
Note that the SQLDialect.H2 database only supports single-table,
RECURSIVE common table expression lists.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
Note that the SQLDialect.H2 database only supports single-table,
RECURSIVE common table expression lists.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
Note that the SQLDialect.H2 database only supports single-table,
RECURSIVE common table expression lists.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(Name) for strictly non-recursive CTE
and withRecursive(Name) for strictly
recursive CTE.
Note that the SQLDialect.H2 database only supports single-table,
RECURSIVE common table expression lists.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(Name, Name...) for strictly non-recursive CTE
and withRecursive(Name, Name...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(Name, Name...) for strictly non-recursive CTE
and withRecursive(Name, Name...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
Note that the SQLDialect.H2 database only supports single-table,
RECURSIVE common table expression lists.
This works in a similar way as with(String, String...), except
that all column names are produced by a function that receives the CTE's
Select columns as input.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
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
with(String, String...) for strictly non-recursive CTE
and withRecursive(String, String...) for strictly
recursive CTE.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
Reusable CommonTableExpression types can be constructed through
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
with(CommonTableExpression...) for strictly non-recursive CTE
and withRecursive(CommonTableExpression...) for strictly
recursive CTE.
Note that the SQLDialect.H2 database only supports single-table,
RECURSIVE common table expression lists.
WITH clause to supply subsequent
SELECT, UPDATE, INSERT,
DELETE, and MERGE statements with
CommonTableExpressions.
Reusable CommonTableExpression types can be constructed through
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
with(CommonTableExpression...) for strictly non-recursive CTE
and withRecursive(CommonTableExpression...) for strictly
recursive CTE.
Note that the SQLDialect.H2 database only supports single-table,
RECURSIVE common table expression lists.
This will project the known columns from the argument table querying
Fields.fields(). If no known columns are available (e.g. because
the table has been created using table(String)), then
SELECT * is projected.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
SELECT table.col1, table.col2 FROM table
*.
Without knowing any columns from the argument table (see
selectFrom(TableLike)), this will project SELECT *.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
SELECT * FROM table
*.
Without knowing any columns from the argument table (see
selectFrom(TableLike)), this will project SELECT *.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
SELECT * FROM table
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
*.
Without knowing any columns from the argument table (see
selectFrom(TableLike)), this will project SELECT *.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
SELECT * FROM table
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
*.
Without knowing any columns from the argument table (see
selectFrom(TableLike)), this will project SELECT *.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
SELECT * FROM table
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
*.
Without knowing any columns from the argument table (see
selectFrom(TableLike)), this will project SELECT *.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
SELECT * FROM table
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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:
SELECT tab1.col1, tab1.col2, …, tabN.colN if
all columns are knownSELECT * if not all columns are known, e.g. when
using plain SQL
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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:
SELECT tab1.col1, tab1.col2, …, tabN.colN if
all columns are knownSELECT * if not all columns are known, e.g. when
using plain SQL
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Field.in(Select), Field.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row2.in(Select), Row2.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row3.in(Select), Row3.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row4.in(Select), Row4.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row5.in(Select), Row5.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row6.in(Select), Row6.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row7.in(Select), Row7.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row8.in(Select), Row8.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row9.in(Select), Row9.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row10.in(Select), Row10.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row11.in(Select), Row11.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row12.in(Select), Row12.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row13.in(Select), Row13.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row14.in(Select), Row14.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row15.in(Select), Row15.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row16.in(Select), Row16.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row17.in(Select), Row17.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row18.in(Select), Row18.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row19.in(Select), Row19.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.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);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row20.in(Select), Row20.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field19, field20)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row21.in(Select), Row21.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field20, field21)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...), except that it declares
additional record-level typesafety, which is needed by
Row22.in(Select), Row22.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field21, field22)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(fields)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
Note that passing an empty collection conveniently produces
SELECT DISTINCT * semantics, i.e. it:
SELECT DISTINCT tab1.col1, tab1.col2, …, tabN.colN if
all columns are knownSELECT DISTINCT * if not all columns are known, e.g. when
using plain SQL
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(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 DISTINCT * semantics, i.e. it:
SELECT DISTINCT tab1.col1, tab1.col2, …, tabN.colN if
all columns are knownSELECT DISTINCT * if not all columns are known, e.g. when
using plain SQL
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Field.in(Select), Field.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row2.in(Select), Row2.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row3.in(Select), Row3.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row4.in(Select), Row4.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, field4)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row5.in(Select), Row5.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, field4, field5)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row6.in(Select), Row6.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field5, field6)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row7.in(Select), Row7.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field6, field7)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row8.in(Select), Row8.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field7, field8)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row9.in(Select), Row9.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field8, field9)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row10.in(Select), Row10.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field9, field10)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row11.in(Select), Row11.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field10, field11)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row12.in(Select), Row12.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field11, field12)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row13.in(Select), Row13.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field12, field13)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row14.in(Select), Row14.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field13, field14)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row15.in(Select), Row15.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field14, field15)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row16.in(Select), Row16.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field15, field16)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row17.in(Select), Row17.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field16, field17)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row18.in(Select), Row18.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field17, field18)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row19.in(Select), Row19.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field18, field19)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row20.in(Select), Row20.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field19, field20)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row21.in(Select), Row21.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field20, field21)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it
declares additional record-level typesafety, which is needed by
Row22.in(Select), Row22.equal(Select) and other predicate
building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field21, field22)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
0
literal.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectZero()
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
1
literal.
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectOne()
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
COUNT(*).
Unlike Select factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
SELECT statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)Example:
import static org.jooq.impl.DSL.*;
// [...]
selectCount()
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
This type of insert may feel more convenient to some users, as it uses
the UPDATE statement's SET a = b syntax.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table)
.set(field1, value1)
.set(field2, value2)
.newRecord()
.set(field1, value3)
.set(field2, value4)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1)
.values(field1)
.values(field1)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2)
.values(field1, field2)
.values(field1, field2)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3)
.values(field1, field2, field3)
.values(field1, field2, field3)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, field4)
.values(field1, field2, field3, field4)
.values(field1, field2, field3, field4)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, field4, field5)
.values(field1, field2, field3, field4, field5)
.values(field1, field2, field3, field4, field5)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field5, field6)
.values(valueA1, valueA2, valueA3, .., valueA5, valueA6)
.values(valueB1, valueB2, valueB3, .., valueB5, valueB6)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field6, field7)
.values(valueA1, valueA2, valueA3, .., valueA6, valueA7)
.values(valueB1, valueB2, valueB3, .., valueB6, valueB7)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field7, field8)
.values(valueA1, valueA2, valueA3, .., valueA7, valueA8)
.values(valueB1, valueB2, valueB3, .., valueB7, valueB8)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field8, field9)
.values(valueA1, valueA2, valueA3, .., valueA8, valueA9)
.values(valueB1, valueB2, valueB3, .., valueB8, valueB9)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field9, field10)
.values(valueA1, valueA2, valueA3, .., valueA9, valueA10)
.values(valueB1, valueB2, valueB3, .., valueB9, valueB10)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field10, field11)
.values(valueA1, valueA2, valueA3, .., valueA10, valueA11)
.values(valueB1, valueB2, valueB3, .., valueB10, valueB11)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field11, field12)
.values(valueA1, valueA2, valueA3, .., valueA11, valueA12)
.values(valueB1, valueB2, valueB3, .., valueB11, valueB12)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field12, field13)
.values(valueA1, valueA2, valueA3, .., valueA12, valueA13)
.values(valueB1, valueB2, valueB3, .., valueB12, valueB13)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field13, field14)
.values(valueA1, valueA2, valueA3, .., valueA13, valueA14)
.values(valueB1, valueB2, valueB3, .., valueB13, valueB14)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field14, field15)
.values(valueA1, valueA2, valueA3, .., valueA14, valueA15)
.values(valueB1, valueB2, valueB3, .., valueB14, valueB15)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field15, field16)
.values(valueA1, valueA2, valueA3, .., valueA15, valueA16)
.values(valueB1, valueB2, valueB3, .., valueB15, valueB16)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field16, field17)
.values(valueA1, valueA2, valueA3, .., valueA16, valueA17)
.values(valueB1, valueB2, valueB3, .., valueB16, valueB17)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field17, field18)
.values(valueA1, valueA2, valueA3, .., valueA17, valueA18)
.values(valueB1, valueB2, valueB3, .., valueB17, valueB18)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field18, field19)
.values(valueA1, valueA2, valueA3, .., valueA18, valueA19)
.values(valueB1, valueB2, valueB3, .., valueB18, valueB19)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field19, field20)
.values(valueA1, valueA2, valueA3, .., valueA19, valueA20)
.values(valueB1, valueB2, valueB3, .., valueB19, valueB20)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field20, field21)
.values(valueA1, valueA2, valueA3, .., valueA20, valueA21)
.values(valueB1, valueB2, valueB3, .., valueB20, valueB21)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field21, field22)
.values(valueA1, valueA2, valueA3, .., valueA21, valueA22)
.values(valueB1, valueB2, valueB3, .., valueB21, valueB22)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2)
.values(valueA1, valueA2)
.values(valueB1, valueB2)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
INSERT statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2)
.values(valueA1, valueA2)
.values(valueB1, valueB2)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Update factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
UPDATE statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
update(table)
.set(field1, value1)
.set(field2, value2)
.where(field1.greaterThan(100))
Note that some databases support table expressions more complex than simple table references. In MySQL, for instance, you can write
update(t1.join(t2).on(t1.id.eq(t2.id)))
.set(t1.value, value1)
.set(t2.value, value2)
.where(t1.id.eq(10))
Unlike Merge factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
MERGE statement.
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| dialect | support type | documentation |
|---|---|---|
| DB2 | SQL:2008 standard and major enhancements | http://publib.boulder.ibm.com/infocenter/db2luw/v9/index.jsp?topic=/com. ibm.db2.udb.admin.doc/doc/r0010873.htm |
| HSQLDB | SQL:2008 standard | http://hsqldb.org/doc/2.0/guide/dataaccess-chapt.html#N129BA |
| Oracle | SQL:2008 standard and minor enhancements | http://download.oracle.com/docs/cd/B28359_01/server.111/b28286/ statements_9016.htm |
| SQL Server | Similar to SQL:2008 standard with some major enhancements | http://msdn.microsoft.com/de-de/library/bb510625.aspx |
| Sybase | Similar to SQL:2008 standard with some major enhancements | http://dcx.sybase.com/1100/en/dbreference_en11/merge-statement.html |
Example:
import static org.jooq.impl.DSL.*;
// [...]
mergeInto(table)
.using(select)
.on(condition)
.whenMatchedThenUpdate()
.set(field1, value1)
.set(field2, value2)
.whenNotMatchedThenInsert(field1, field2)
.values(value1, value2)
Note: Using this method, you can also create an H2-specific MERGE
statement without field specification. See also
mergeInto(Table, Field...)
mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)mergeInto(Table)
Unlike Merge factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
MERGE statement.
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | https://www.h2database.com/html/commands.html#merge_into |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can emulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
mergeInto(Table)
Unlike Merge factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
MERGE statement.
Unlike Delete factory methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
DELETE statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
deleteFrom(table)
.where(field1.greaterThan(100))
Some but not all databases support aliased tables in delete statements.
This is an alias for deleteFrom(Table)
CONSTRAINT specification.CONSTRAINT specification.CONSTRAINT specification.PRIMARY KEY constraint.PRIMARY KEY constraint.PRIMARY KEY constraint.PRIMARY KEY constraint.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.FOREIGN KEY clause to the CONSTRAINT.UNIQUE constraint.UNIQUE constraint.UNIQUE constraint.UNIQUE constraint.CHECK constraint.ALTER DATABASE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DATABASE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DATABASE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DATABASE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DATABASE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DATABASE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER TYPE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER TYPE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER MATERIALIZED VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER MATERIALIZED VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER MATERIALIZED VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON COLUMN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON COLUMN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMENT ON COLUMN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DATABASE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DATABASE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DATABASE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DATABASE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DATABASE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DATABASE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DOMAIN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DOMAIN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DOMAIN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DOMAIN IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DOMAIN IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE DOMAIN IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE FUNCTION statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE FUNCTION statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE FUNCTION statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE FUNCTION statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE INDEX IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE INDEX IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE INDEX IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE INDEX IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE UNIQUE INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE UNIQUE INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE UNIQUE INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE UNIQUE INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE UNIQUE INDEX IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE UNIQUE INDEX IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE UNIQUE INDEX IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE UNIQUE INDEX IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE PROCEDURE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE PROCEDURE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE PROCEDURE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE PROCEDURE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TABLE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TABLE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TABLE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TEMPORARY TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TEMPORARY TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TEMPORARY TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TEMPORARY TABLE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TEMPORARY TABLE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TEMPORARY TABLE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE GLOBAL TEMPORARY TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE GLOBAL TEMPORARY TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE GLOBAL TEMPORARY TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE GLOBAL TEMPORARY TABLE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE GLOBAL TEMPORARY TABLE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE GLOBAL TEMPORARY TABLE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE MATERIALIZED VIEW IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TRIGGER statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TRIGGER statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TRIGGER statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE TRIGGER statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE TRIGGER statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE OR REPLACE TRIGGER statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TYPE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TYPE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE TYPE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SCHEMA statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SCHEMA statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SCHEMA statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SCHEMA IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SCHEMA IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SCHEMA IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE IF NOT EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP FUNCTION statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP FUNCTION statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP FUNCTION IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP FUNCTION IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP PROCEDURE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP PROCEDURE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP PROCEDURE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP PROCEDURE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TRIGGER statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TRIGGER statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TRIGGER statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TRIGGER IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TRIGGER IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TRIGGER IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TYPE IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP MATERIALIZED VIEW statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP MATERIALIZED VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP MATERIALIZED VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP MATERIALIZED VIEW IF EXISTS statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
GRANT statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
GRANT statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
GRANT statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
REVOKE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
REVOKE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
REVOKE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
REVOKE GRANT OPTION FOR statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
REVOKE GRANT OPTION FOR statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
REVOKE GRANT OPTION FOR statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SET statement.
Set a vendor specific session configuration to a new value.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SET statement.
Set a vendor specific session configuration to a new value.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SET LOCAL statement.
Set a vendor specific transaction-local configuration to a new value.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SET LOCAL statement.
Set a vendor specific transaction-local configuration to a new value.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SET CATALOG statement.
Set the current catalog to a new value.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SET CATALOG statement.
Set the current catalog to a new value.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SET CATALOG statement.
Set the current catalog to a new value.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SET SCHEMA statement.
Set the current schema to a new value.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SET SCHEMA statement.
Set the current schema to a new value.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SET SCHEMA statement.
Set the current schema to a new value.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
TRUNCATE TABLE statement.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CALL statement.
Call a stored procedure.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CALL statement.
Call a stored procedure.
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
START TRANSACTION statement.
Start a transaction
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SAVEPOINT statement.
Specify a savepoint
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
SAVEPOINT statement.
Specify a savepoint
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
RELEASE SAVEPOINT statement.
Release a savepoint
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
RELEASE SAVEPOINT statement.
Release a savepoint
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
COMMIT statement.
Commit a transaction
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ROLLBACK statement.
Rollback a transaction
Unlike statement construction methods in the DSLContext API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE VIEW statement.
This works like createView(Table, Field...) except that the
view's field names are derived from the view's Select statement
using a function.
CREATE VIEW statement.
This works like createView(Table, Field...) except that the
view's field names are derived from the view's Select statement
using a function.
CREATE VIEW statement.
This works like createView(Table, Field...) except that the
view's field names are derived from the view's Select statement
using a function.
CREATE OR REPLACE VIEW statement.
This works like createOrReplaceView(Table, Field...) except that the
view's field names are derived from the view's Select statement
using a function.
CREATE OR REPLACE VIEW statement.
This works like createOrReplaceView(Table, Field...) except that the
view's field names are derived from the view's Select statement
using a function.
CREATE OR REPLACE VIEW statement.
This works like createOrReplaceView(Table, Field...) except that the
view's field names are derived from the view's Select statement
using a function.
CREATE VIEW IF NOT EXISTS statement.
This works like createViewIfNotExists(String, String...) except that the
view's field names are derived from the view's Select statement
using a function.
CREATE VIEW IF NOT EXISTS statement.
This works like createViewIfNotExists(Name, Name...) except that the
view's field names are derived from the view's Select statement
using a function.
CREATE VIEW IF NOT EXISTS statement.
This works like createViewIfNotExists(Table, Field...) except that the
view's field names are derived from the view's Select statement
using a function.
ALTER TABLE statement.ALTER TABLE statement.ALTER TABLE statement.ALTER TABLE statement.ALTER TABLE statement.ALTER TABLE statement.ALL quantified select to be used in quantified
comparison predicate expressions.ALL quantified select to be used in quantified
comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects
will render a subselect unnesting the array.
ALL quantified select to be used in quantified
comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects
will render a subselect unnesting the array.
ALL quantified select to be used in quantified
comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects
will render a subselect unnesting the array.
ANY quantified select to be used in quantified
comparison predicate expressions.ANY quantified select to be used in quantified
comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects
will render a subselect unnesting the array.
ANY quantified select to be used in quantified
comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects
will render a subselect unnesting the array.
ANY quantified select to be used in quantified
comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects
will render a subselect unnesting the array.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NEW to
retrieve the modified data from after the Update or
Insert statement was applied.
Depending on the dialect, this may show data after all referential integrity validation and all triggers have been executed or fired, meaning there will be no more additional modification to the "final" version of the modified data.
NEW to
retrieve the modified data from after the Update or
Insert statement was applied.
Depending on the dialect, this may show data after all referential integrity validation and all triggers have been executed or fired, meaning there will be no more additional modification to the "final" version of the modified data.
NEW to
retrieve the modified data from after the Update or
Insert statement was applied.
Depending on the dialect, this may show data after all referential integrity validation and all triggers have been executed or fired, meaning there will be no more additional modification to the "final" version of the modified data.
TableLike.asTable(), which might look a bit more fluent
like this, to some users.Table that can be used
in SQL statements through values(RowN...).unnest(Collection).unnest(Object[]).unnest(ArrayRecord).unnest(Field).
This is equivalent to the TABLE function for H2, or the
UNNEST function in HSQLDB and Postgres
For Oracle, use table(ArrayRecord) instead, as Oracle knows only
typed arrays
In all other dialects, unnesting of arrays is emulated using several
UNION ALL connected subqueries.
This is equivalent to the TABLE function for H2, or the
UNNEST function in HSQLDB and Postgres
For Oracle, use table(ArrayRecord) instead, as Oracle knows only
typed arrays
In all other dialects, unnesting of arrays is emulated using several
UNION ALL connected subqueries.
This wraps the argument array in a TABLE function for
Oracle. Currently, only Oracle knows typed arrays
The supplied field can have any of these types:
Result: For CURSOR or REF CURSOR
fields, typically fetched from stored functions or from nested tablesArrayRecord: For Oracle-style VARRAY types.Object[]: Array types, for other RDBMS's ARRAY types (e.g.
H2, HSQLDB, and Postgres)Object: Any other type that jOOQ will try to convert in an
array first, before converting that array into a table
This functionality has only limited scope when used in H2, as ARRAY types
involved with stored functions can only be of type Object[].
Such arrays are converted into VARCHAR arrays by jOOQ.
In all dialects where arrays are not supported, unnesting of arrays is
emulated using several UNION ALL connected subqueries.
DUAL table to be used for syntactic completeness.
In general, jOOQ will generate a DUAL table (or any
equivalent construct, see below), if this is needed syntactically in
generated SQL. You may still wish to explicitly use a DUAL
construct in jOOQ code for various reasons. This DUAL table
will always contain a single record with a single varchar(1) value:
+-------+
| DUMMY |
+-------+
| X |
+-------+
from to
to (inclusive).
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to) function. Other SQL dialects may
be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b)
-- Oracle
SELECT * FROM (SELECT a + LEVEL - 1 FROM DUAL CONNECT BY a + LEVEL - 1 <= b)
from to
to (inclusive).
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to) function. Other SQL dialects may
be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b)
-- Oracle
SELECT * FROM (SELECT a + LEVEL - 1 FROM DUAL CONNECT BY a + LEVEL - 1 <= b)
from to
to (inclusive).
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to) function. Other SQL dialects may
be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b)
-- Oracle
SELECT * FROM (SELECT a + LEVEL - 1 FROM DUAL CONNECT BY a + LEVEL - 1 <= b)
from to
to (inclusive).
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to) function. Other SQL dialects may
be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b)
-- Oracle
SELECT * FROM (SELECT a + LEVEL - 1 FROM DUAL CONNECT BY a + LEVEL - 1 <= b)
from to
to (inclusive), increasing values by step.
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to, step) function. Other SQL dialects
may be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b, c)
-- Oracle
SELECT * FROM (SELECT a + LEVEL * c- 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)
from to
to (inclusive), increasing values by step.
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to, step) function. Other SQL dialects may
be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b, c)
-- Oracle
SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)
from to
to (inclusive), increasing values by step.
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to, step) function. Other SQL dialects may
be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b, c)
-- Oracle
SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)
from to
to (inclusive), increasing values by step.
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to, step) function. Other SQL dialects may
be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b, c)
-- Oracle
SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)
from to
to (inclusive), increasing values by step.
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to, step) function. Other SQL dialects
may be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b, c)
-- Oracle
SELECT * FROM (SELECT a + LEVEL * c- 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)
from to
to (inclusive), increasing values by step.
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to, step) function. Other SQL dialects may
be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b, c)
-- Oracle
SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)
from to
to (inclusive), increasing values by step.
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to, step) function. Other SQL dialects may
be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b, c)
-- Oracle
SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)
from to
to (inclusive), increasing values by step.
This function is inspired by PostgreSQL's
GENERATE_SERIES(from, to, step) function. Other SQL dialects may
be capable of emulating this behaviour, e.g. Oracle:
-- PostgreSQL
SELECT * FROM GENERATE_SERIES(a, b, c)
-- Oracle
SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)
LATERAL joined table.
Example:
SELECT *
FROM employees e,
LATERAL(SELECT * FROM departments d
WHERE e.department_id = d.department_id);
ROWS FROM (tables…) expression.
Example:
SELECT *
FROM ROWS FROM (function1('a', 'b'), function2('c', 'd'));
This allows for full outer joining several table-valued functions on the row number of each function's produced rows.
A Keyword is a QueryPart that renders a SQL keyword
according to the settings specified in
Settings.getRenderKeywordCase(). It can be embedded in other
plain SQL QueryParts as shown in this example:
Condition c = condition("{0} {1} {2} {3} {4}",
value1, keyword("between")
value2, keyword("and")
value3
);
Use this method to construct syntax-safe, SQL-injection-safe SQL
identifiers for use in plain SQL where QueryPart objects are
accepted. For instance, this can be used with any of these methods:
An example:
// This unqualified name here
name("book");
// ... will render this SQL by default, using the SQL Server dialect
[book].[title]
unqualifiedName - The SQL identifier's unqualified nameQueryPart that will render the SQL identifier
Use this method to construct syntax-safe, SQL-injection-safe SQL
identifiers for use in plain SQL where QueryPart objects are
accepted. For instance, this can be used with any of these methods:
An example:
// This qualified name here
name("book", "title");
// ... will render this SQL by default, using the SQL Server dialect
[book].[title]
qualifiedName - The SQL identifier's qualified name partsQueryPart that will render the SQL identifier
Unlike other name(String...) constructors, this one constructs a
name from its argument Name.unqualifiedName() parts, retaining
the quoted flag, to construct a new name.
Use this method to construct syntax-safe, SQL-injection-safe SQL
identifiers for use in plain SQL where QueryPart objects are
accepted. For instance, this can be used with any of these methods:
An example:
// This qualified name here
name(quotedName("book"), unquotedName("title"));
// ... will render this SQL by default, using the SQL Server dialect
[book].title
nameParts - The SQL identifier's qualified name partsQueryPart that will render the SQL identifier
Use this method to construct syntax-safe, SQL-injection-safe SQL
identifiers for use in plain SQL where QueryPart objects are
accepted. For instance, this can be used with any of these methods:
An example:
// This qualified name here
name("book", "title");
// ... will render this SQL by default, using the SQL Server dialect
[book].[title]
qualifiedName - The SQL identifier's qualified name partsQueryPart that will render the SQL identifier
This works like name(String...), except that generated
identifiers will be quoted by default in databases that support quoted
identifiers, exept if forced to be unquoted using
Settings.getRenderQuotedNames() with value
RenderQuotedNames.NEVER.
unqualifiedName - The SQL identifier's unqualified nameQueryPart that will render the SQL identifier
This works like name(String...), except that generated
identifiers will be quoted by default in databases that support quoted
identifiers, exept if forced to be unquoted using
Settings.getRenderQuotedNames() with value
RenderQuotedNames.NEVER.
qualifiedName - The SQL identifier's qualified name partsQueryPart that will render the SQL identifier
This works like name(Collection), except that generated
identifiers will be quoted by default in databases that support quoted
identifiers, exept if forced to be unquoted using
Settings.getRenderQuotedNames() with value
RenderQuotedNames.NEVER.
qualifiedName - The SQL identifier's qualified name partsQueryPart that will render the SQL identifier
This works like name(String), except that generated
identifiers will be unquoted by default, except if forced to be quoted
using Settings.getRenderQuotedNames() with value
RenderQuotedNames.ALWAYS.
unqualifiedName - The SQL identifier's unqualified nameQueryPart that will render the SQL identifier
This works like name(String...), except that generated
identifiers will be unquoted by default, except if forced to be quoted
using Settings.getRenderQuotedNames() with value
RenderQuotedNames.ALWAYS.
qualifiedName - The SQL identifier's qualified name partsQueryPart that will render the SQL identifier
This works like name(Collection), except that generated
identifiers will be unquoted by default, except if forced to be quoted
using Settings.getRenderQuotedNames() with value
RenderQuotedNames.ALWAYS.
qualifiedName - The SQL identifier's qualified name partsQueryPart that will render the SQL identifier
This works like unquotedName(String), except that generated
identifiers will be guaranteed to be unquoted, even when the relevant
Settings.getRenderQuotedNames() flag is set to
RenderQuotedNames.ALWAYS.
unqualifiedName - The SQL identifier's unqualified nameQueryPart that will render the SQL identifier
This works like unquotedName(String...), except that generated
identifiers will be guaranteed to be unquoted, even when the relevant
Settings.getRenderQuotedNames() flag is set to
RenderQuotedNames.ALWAYS.
qualifiedName - The SQL identifier's qualified name partsQueryPart that will render the SQL identifier
This works like unquotedName(Collection), except that generated
identifiers will be guaranteed to be unquoted, even when the relevant
Settings.getRenderQuotedNames() flag is set to
RenderQuotedNames.ALWAYS.
qualifiedName - The SQL identifier's qualified name partsQueryPart that will render the SQL identifierQueryParts into a new
QueryPart, with individual parts being comma-separated.QueryParts into a new
QueryPart, with individual parts being comma-separated.DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.
While the DEFAULT keyword works with all data types, you may
still prefer to associate a Field type with your
DEFAULT value. In that case, use
defaultValue(Class) or defaultValue(DataType) instead.
This is an alias for default_().
DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.
This is an alias for default_(Class).
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType. If you're using any custom data types by means of a
Converter or Binding, it's better to pass that converted
DataType reference explicitly to
defaultValue(DataType).
DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.
This is an alias for default_(DataType).
DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.
This is an alias for default_(Field).
DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.
While the DEFAULT keyword works with all data types, you may
still prefer to associate a Field type with your
DEFAULT value. In that case, use
defaultValue(Class) or defaultValue(DataType) instead.
DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
default_(DataType).
DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.DEFAULT keyword for use with INSERT,
UPDATE, or MERGE statements.Table that behaves like no table being present.
When creating dynamic SQL queries using expressions, it is often useful
to be able to decide dynamically whether a clause is being added to a
query or not. In case that clause accepts tables, the noTable()
can be used to avoid creating a FROM clause or a join
operation.
NOTE [#16918] that this Table is meant to be used with the
DSL API only, not with the QOM API, which cannot offer
any no-op operations. The behaviour when used with the QOM API is
undefined.
Field that behaves like no field being present.
When creating dynamic SQL queries using expressions, it is often useful
to be able to decide dynamically whether a clause is being added to a
query or not. In case that clause accepts fields, the noField()
can be used to avoid creating a clause, which is useful for the following
Select clauses, for example:
SelectGroupByStep.groupBy(GroupField...)SelectOrderByStep.orderBy(OrderField...)SelectLimitStep.limit(Field)SelectOffsetStep.offset(Field)Record type, the
noField() simply projects NULL and cannot be used
to avoid the clause.
NOTE [#16918] that this Field is meant to be used with the
DSL API only, not with the QOM API, which cannot offer
any no-op operations. The behaviour when used with the QOM API is
undefined.
Field that behaves like no field being present.
When creating dynamic SQL queries using expressions, it is often useful
to be able to decide dynamically whether a clause is being added to a
query or not. In case that clause accepts fields, the noField()
can be used to avoid creating a clause, which is useful for the following
Select clauses, for example:
SelectGroupByStep.groupBy(GroupField...)SelectOrderByStep.orderBy(OrderField...)SelectLimitStep.limit(Field)SelectOffsetStep.offset(Field)Record type, the
noField() simply projects NULL and cannot be used
to avoid the clause.
NOTE [#15286]: It is strongly recommended to pass only Class references
of types supported by jOOQ internally, i.e. types from
SQLDataType. If you're using any custom data types by means of a
Converter or Binding, it's better to pass that converted
DataType reference explicitly to noField(DataType).
NOTE [#16918] that this Field is meant to be used with the
DSL API only, not with the QOM API, which cannot offer
any no-op operations. The behaviour when used with the QOM API is
undefined.
type - A class to derive the Typed.getDataType() from.Field that behaves like no field being present.
When creating dynamic SQL queries using expressions, it is often useful
to be able to decide dynamically whether a clause is being added to a
query or not. In case that clause accepts fields, the noField()
can be used to avoid creating a clause, which is useful for the following
Select clauses, for example:
SelectGroupByStep.groupBy(GroupField...)SelectOrderByStep.orderBy(OrderField...)SelectLimitStep.limit(Field)SelectOffsetStep.offset(Field)Record type, the
noField() simply projects NULL and cannot be used
to avoid the clause.
NOTE [#16918] that this Field is meant to be used with the
DSL API only, not with the QOM API, which cannot offer
any no-op operations. The behaviour when used with the QOM API is
undefined.
type - A type to derive the Typed.getDataType() from.Field that behaves like no field being present.
When creating dynamic SQL queries using expressions, it is often useful
to be able to decide dynamically whether a clause is being added to a
query or not. In case that clause accepts fields, the noField()
can be used to avoid creating a clause, which is useful for the following
Select clauses, for example:
SelectGroupByStep.groupBy(GroupField...)SelectOrderByStep.orderBy(OrderField...)SelectLimitStep.limit(Field)SelectOffsetStep.offset(Field)Record type, the
noField() simply projects NULL and cannot be used
to avoid the clause.
NOTE [#16918] that this Field is meant to be used with the
DSL API only, not with the QOM API, which cannot offer
any no-op operations. The behaviour when used with the QOM API is
undefined.
type - A field to derive the Typed.getDataType() from.This constructs a catalog reference given the catalog's qualified name.
Example:
// This catalog...
catalog(name("MY_CATALOG"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_CATALOG]
This constructs a catalog reference given the catalog's qualified name.
Example:
// This catalog...
catalog(name("MY_CATALOG"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_CATALOG]
This constructs a schema reference given the schema's qualified name.
Example:
// This schema...
schema(name("MY_CATALOG", "MY_SCHEMA"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_CATALOG].[MY_SCHEMA]
This constructs a schema reference given the schema's qualified name.
Example:
// This schema...
schema(name("MY_CATALOG", "MY_SCHEMA"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_CATALOG].[MY_SCHEMA]
This constructs a sequence reference given the sequence's qualified name.
Example:
// This sequence...
sequence(name("MY_SCHEMA", "MY_SEQUENCE"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_SEQUENCE]
This constructs a sequence reference given the sequence's qualified name.
Example:
// This sequence...
sequence(name("MY_SCHEMA", "MY_SEQUENCE"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_SEQUENCE]
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType. If you're using any custom data types by means of a
Converter or Binding, it's better to pass that converted
DataType reference explicitly to
sequence(Name, DataType).
name - The sequence nametype - The sequence type (a type that is supported by
SQLDataType)This constructs a sequence reference given the sequence's qualified name.
Example:
// This sequence...
sequence(name("MY_SCHEMA", "MY_SEQUENCE"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_SEQUENCE]
This constructs a table reference given the table's qualified name. jOOQ
Example:
// This table...
tableByName("MY_SCHEMA", "MY_TABLE");
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE]
The returned table does not know its field references, i.e.
Fields.fields() returns an empty array.
This constructs a table reference given the table's qualified name. jOOQ
Example:
// This table...
tableByName("MY_SCHEMA", "MY_TABLE");
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE]
The returned table does not know its field references, i.e.
Fields.fields() returns an empty array.
This constructs a field reference given the field's qualified name. jOOQ
Example:
// This field...
field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE].[MY_FIELD]
Another example:
create.select(field("length({1})", Integer.class, field(name("TITLE"))))
.from(table(name("T_BOOK")))
.fetch();
// ... will execute this SQL on SQL Server:
select length([TITLE]) from [T_BOOK]
NOTE: A lot of things work less well in jOOQ if no
DataType information is attached to a Field expression,
including:
NULL values.field(Name, DataType), instead,
or even better, use code generation where possible: https://blog.jooq.org/why-you-should-use-jooq-with-code-generation/,
in case of which DataType information is attached to all
Field expressions automatically.This constructs a field reference given the field's qualified name. jOOQ
Example:
// This field...
field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE].[MY_FIELD]
Another example:
create.select(field("length({1})", Integer.class, field(name("TITLE"))))
.from(table(name("T_BOOK")))
.fetch();
// ... will execute this SQL on SQL Server:
select length([TITLE]) from [T_BOOK]
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType. If you're using any custom data types by means of a
Converter or Binding, it's better to pass that converted
DataType reference explicitly to
field(Name, DataType).
name - The field nametype - The field type (a type that is supported by
SQLDataType)This constructs a field reference given the field's qualified name. jOOQ
Example:
// This field...
field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE].[MY_FIELD]
Another example:
create.select(field("length({1})", Integer.class, field(name("TITLE"))))
.from(table(name("T_BOOK")))
.fetch();
// ... will execute this SQL on SQL Server:
select length([TITLE]) from [T_BOOK]
This constructs a field reference given the field's qualified name. jOOQ
Example:
// This field...
field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE].[MY_FIELD]
Another example:
create.select(field("length({1})", Integer.class, field(name("TITLE"))))
.from(table(name("T_BOOK")))
.fetch();
// ... will execute this SQL on SQL Server:
select length([TITLE]) from [T_BOOK]
Period reference.Period reference.
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType. If you're using any custom data types by means of a
Converter or Binding, it's better to pass that converted
DataType reference explicitly to
period(Name, DataType).
name - The period nametype - The period type (a type that is supported by
SQLDataType)Period reference.SYSTEM_TIME Period reference.SYSTEM_TIME Period reference.
NOTE [#15286]: It is strongly recommended to pass only Class references
of types supported by jOOQ internally, i.e. types from
SQLDataType. If you're using any custom data types by means of a
Converter or Binding, it's better to pass that converted
DataType reference explicitly to systemTime(DataType).
SYSTEM_TIME Period reference.IN parameter.IN parameter.IN OUT parameter.IN OUT parameter.OUT parameter.OUT parameter.
A plain SQL QueryPart is a QueryPart that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQL
A plain SQL QueryPart is a QueryPart that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQL
A plain SQL QueryPart is a QueryPart that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQL
A plain SQL QueryPart is a QueryPart that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLBEGIN … END;, unless explicitly needed.BEGIN … END;, unless explicitly needed.var(Name, DataType) to be used in Scala and
Groovy, where var is a reserved keyword.var(Name, DataType) to be used in Scala and
Groovy, where var is a reserved keyword.
Declarations can be inlined in any statement Block as is
supported by databases like SQLDialect.MYSQL or
SQLDialect.SQLSERVER. If the underlying database requires a
dedicated DECLARE section, the section will be generated
automatically and if needed, a nested Block is generated.
Declarations can be inlined in any statement Block as is
supported by databases like SQLDialect.MYSQL or
SQLDialect.SQLSERVER. If the underlying database requires a
dedicated DECLARE section, the section will be generated
automatically and if needed, a nested Block is generated.
Declarations can be inlined in any statement Block as is
supported by databases like SQLDialect.MYSQL or
SQLDialect.SQLSERVER. If the underlying database requires a
dedicated DECLARE section, the section will be generated
automatically and if needed, a nested Block is generated.
Many dialects support some way of running procedural and SQL statements dynamically from within procedural code. For example, in Oracle, this syntax is required to run DDL statements from PL/SQL:
BEGIN
EXECUTE IMMEDIATE 'CREATE TABLE x (i INT)';
END;
IF statement for use in procedural code.WHILE loop for use in procedural code.REPEAT loop for use in procedural code.REPEAT loop for use in procedural code.FOR loop for use in procedural code.LOOP for use in procedural code.LOOP for use in procedural code.EXIT statement for use in procedural code.EXIT statement for use in procedural code.EXIT statement for use in procedural code.EXIT statement for use in procedural code.CONTINUE statement for use in procedural code.CONTINUE statement for use in procedural code.CONTINUE statement for use in procedural code.CONTINUE statement for use in procedural code.
A plain SQL QueryPart is a QueryPart that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
Unlike other ways to create plain SQL templates, this only contains raw String content, without any templating capabilities or bind values.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQL
A plain SQL QueryPart is a QueryPart that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQL
A plain SQL QueryPart is a QueryPart that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
This overload takes a set of QueryPart arguments which are
replaced into the SQL string template at the appropriate index. Example:
// Argument QueryParts are replaced into the SQL string at the appropriate index
sql("select {0}, {1} from {2}", TABLE.COL1, TABLE.COL2, TABLE);
// Bind variables are supported as well, for backwards compatibility
sql("select col1, col2 from table where col1 = ?", val(1));
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locations
A plain SQL QueryPart is a QueryPart that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL. There must be as many bind variables contained
in the SQL, as passed in the bindings parameter
This overload takes a set of bind value arguments which are replaced our bound into the SQL string template at the appropriate index. Example:
sql("select col1, col2 from table where col1 = ?", 1);
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLExample:
String sql = "SET SCHEMA 'abc'";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLExample:
String sql = "SET SCHEMA 'abc'";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLExample:
String sql = "SET SCHEMA 'abc'";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLbindings - The bindings
Unlike query(String, Object...), the SQL passed to this method
should not contain any bind variables. Instead, you can pass
QueryPart objects to the method which will be rendered at indexed
locations of your SQL string as such:
// The following query
query("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
// Will render this SQL by default, using Oracle SQL dialect
select ?, 'test' from "DUAL"
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses! One way to escape
literals is to use name(String...) and similar methods
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locationsThere must not be any bind variables contained in the SQL
Use this method, when you want to take advantage of the many ways to
fetch results in jOOQ, using ResultQuery. Some examples:
ResultQuery.fetchLazy() |
Open a cursor and fetch records one by one |
ResultQuery.fetchInto(Class) |
Fetch records into a custom POJO (optionally annotated with JPA annotations) |
Example (Postgres):
String sql = "FETCH ALL IN \"<unnamed cursor 1>\""; Example
(SQLite):
String sql = "pragma table_info('my_table')";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLThere must not be any bind variables contained in the SQL
Use this method, when you want to take advantage of the many ways to
fetch results in jOOQ, using ResultQuery. Some examples:
ResultQuery.fetchLazy() |
Open a cursor and fetch records one by one |
ResultQuery.fetchInto(Class) |
Fetch records into a custom POJO (optionally annotated with JPA annotations) |
Example (Postgres):
String sql = "FETCH ALL IN \"<unnamed cursor 1>\""; Example
(SQLite):
String sql = "pragma table_info('my_table')";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLThere must be as many bind variables contained in the SQL, as passed in the bindings parameter
Use this method, when you want to take advantage of the many ways to
fetch results in jOOQ, using ResultQuery. Some examples:
ResultQuery.fetchLazy() |
Open a cursor and fetch records one by one |
ResultQuery.fetchInto(Class) |
Fetch records into a custom POJO (optionally annotated with JPA annotations) |
Example (Postgres):
String sql = "FETCH ALL IN \"<unnamed cursor 1>\""; Example
(SQLite):
String sql = "pragma table_info('my_table')";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLbindings - The bindings
Unlike resultQuery(String, Object...), the SQL passed to this
method should not contain any bind variables. Instead, you can pass
QueryPart objects to the method which will be rendered at indexed
locations of your SQL string as such:
// The following query
resultQuery("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
// Will render this SQL by default, using Oracle SQL dialect
select ?, 'test' from "DUAL"
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses! One way to escape
literals is to use name(String...) and similar methods
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locationsA plain SQL table is a table that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex, but static subqueries or tables from different schemas.
Example
String sql = "(SELECT * FROM USER_TABLES WHERE OWNER = 'MY_SCHEMA')";
The returned table does not know its field references, i.e.
Fields.fields() returns an empty array.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLA plain SQL table is a table that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex, but static subqueries or tables from different schemas.
Example
String sql = "(SELECT * FROM USER_TABLES WHERE OWNER = 'MY_SCHEMA')";
The returned table does not know its field references, i.e.
Fields.fields() returns an empty array.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLA plain SQL table is a table that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex, but static subqueries or tables from different schemas. There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example
String sql = "(SELECT * FROM USER_TABLES WHERE OWNER = ?)";
Object[] bindings = new Object[] { "MY_SCHEMA" };
The returned table does not know its field references, i.e.
Fields.fields() returns an empty array.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLA plain SQL table is a table that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex, but static subqueries or tables from different schemas.
Example
String sql = "(SELECT * FROM USER_TABLES WHERE {0})";
QueryPart[] parts = new QueryPart[] { USER_TABLES.OWNER.equal("MY_SCHEMA") };
The returned table does not know its field references, i.e.
Fields.fields() returns an empty array.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locationssequence(Name) instead.NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLsequence(Name, Class)
instead.NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType. If you're using any custom data types by means of a
Converter or Binding, it's better to pass that converted
DataType reference explicitly to
sequence(String, DataType).
sql - The sequence nametype - The sequence type (a type that is supported by
SQLDataType)sequence(Name, DataType)
instead.NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLtype - The field typeVALUE pseudo field for usage with
DOMAIN specifications.
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType. If you're using any custom data types by means of a
Converter or Binding, it's better to pass that converted
DataType reference explicitly to
value(DataType).
VALUE pseudo field for usage with
DOMAIN specifications.DOMAIN reference.DOMAIN reference.DOMAIN reference.
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType. If you're using any custom data types by means of a
Converter or Binding, it's better to pass that converted
DataType reference explicitly to
domain(String, DataType).
DOMAIN reference.
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType. If you're using any custom data types by means of a
Converter or Binding, it's better to pass that converted
DataType reference explicitly to
domain(Name, DataType).
DOMAIN reference.DOMAIN reference.A plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: A lot of things work less well in jOOQ if no
DataType information is attached to a Field expression,
including:
NULL values.field(SQL, DataType), instead, or
even better, use code generation where possible: https://blog.jooq.org/why-you-should-use-jooq-with-code-generation/,
in case of which DataType information is attached to all
Field expressions automatically.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: A lot of things work less well in jOOQ if no
DataType information is attached to a Field expression,
including:
NULL values.field(String, DataType), instead,
or even better, use code generation where possible: https://blog.jooq.org/why-you-should-use-jooq-with-code-generation/,
in case of which DataType information is attached to all
Field expressions automatically.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must be as many binding variables contained in the SQL, as passed in the bindings parameter
Example:
String sql = "DECODE(MY_FIELD, ?, ?, ?)";
Object[] bindings = new Object[] { 1, 100, 200 };
NOTE: A lot of things work less well in jOOQ if no
DataType information is attached to a Field expression,
including:
NULL values.field(String, DataType, Object...), instead,
or even better, use code generation where possible: https://blog.jooq.org/why-you-should-use-jooq-with-code-generation/,
in case of which DataType information is attached to all
Field expressions automatically.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLbindings - The bindings for the fieldA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType. If you're using any custom data types by means of a
Converter or Binding, it's better to pass that converted
DataType reference explicitly to
field(SQL, DataType).
sql - The SQLtype - The field type (a type that is supported by
SQLDataType)A plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
field(String, DataType).
sql - The SQLtype - The field type (a type that is supported by
SQLDataType)A plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must be as many binding variables contained in the SQL, as passed in the bindings parameter
Example:
String sql = "DECODE(MY_FIELD, ?, ?, ?)";
Object[] bindings = new Object[] { 1, 100, 200 };
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
field(String, DataType, Object...).
sql - The SQLtype - The field type (a type that is supported by
SQLDataType)bindings - The bindings for the fieldA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLtype - The field typeA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLtype - The field typeA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must be as many binding variables contained in the SQL, as passed in the bindings parameter
Example:
String sql = "DECODE(MY_FIELD, ?, ?, ?)";
Object[] bindings = new Object[] { 1, 100, 200 };
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLtype - The field typebindings - The bindings for the field
This is useful for constructing more complex SQL syntax elements wherever
Field types are expected. An example for this is MySQL's
GROUP_CONCAT aggregate function, which has MySQL-specific
keywords that are hard to reflect in jOOQ's DSL:
GROUP_CONCAT([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[SEPARATOR str_val])
The above MySQL function can be expressed as such:
field("GROUP_CONCAT(DISTINCT {0} ORDER BY {1} ASC SEPARATOR '-')", expr1, expr2);
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses! One way to escape
literals is to use name(String...) and similar methods
sql - The SQLtype - The field typeparts - The QueryPart objects that are rendered at the
{numbered placeholder} locations
This is useful for constructing more complex SQL syntax elements wherever
Field types are expected. An example for this is MySQL's
GROUP_CONCAT aggregate function, which has MySQL-specific
keywords that are hard to reflect in jOOQ's DSL:
GROUP_CONCAT([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[SEPARATOR str_val])
The above MySQL function can be expressed as such:
field("GROUP_CONCAT(DISTINCT {0} ORDER BY {1} ASC SEPARATOR '-')", expr1, expr2);
NOTE: A lot of things work less well in jOOQ if no
DataType information is attached to a Field expression,
including:
NULL values.field(String, DataType, QueryPart...), instead,
or even better, use code generation where possible: https://blog.jooq.org/why-you-should-use-jooq-with-code-generation/,
in case of which DataType information is attached to all
Field expressions automatically.
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses! One way to escape
literals is to use name(String...) and similar methods
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locations
This is useful for constructing more complex SQL syntax elements wherever
Field types are expected. An example for this is MySQL's
GROUP_CONCAT aggregate function, which has MySQL-specific
keywords that are hard to reflect in jOOQ's DSL:
GROUP_CONCAT([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[SEPARATOR str_val])
The above MySQL function can be expressed as such:
field("GROUP_CONCAT(DISTINCT {0} ORDER BY {1} ASC SEPARATOR '-')", expr1, expr2);
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses! One way to escape
literals is to use name(String...) and similar methods
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
field(String, DataType, QueryPart...).
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedtype - The field type (a type that is supported by
SQLDataType)parts - The QueryPart objects that are rendered at the
{numbered placeholder} locationsfunction() can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
function(String, DataType, Field...).
name - The function name (without parentheses)type - The function return type (a type that is supported by
SQLDataType)arguments - The function argumentsfunction() can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
name - The function name (without parentheses)type - The function return typearguments - The function argumentsfunction() can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
function(Name, DataType, Field...).
name - The function name (possibly qualified)type - The function return type (a type that is supported by
SQLDataType)arguments - The function argumentsfunction() can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.name - The function name (possibly qualified)type - The function return typearguments - The function argumentsaggregate() can be used to access native or user-defined
aggregate functions that are not yet or insufficiently supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
aggregate(String, DataType, Field...).
name - The aggregate function name (possibly qualified)type - The aggregate function return type (a type that is supported
by SQLDataType)arguments - The aggregate function argumentsaggregate() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
name - The aggregate function nametype - The aggregate function return typearguments - The aggregate function argumentsaggregate() can be used to access native or user-defined
aggregate functions that are not yet or insufficiently supported by jOOQ.
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
aggregate(Name, DataType, Field...).
name - The aggregate function name (possibly qualified)type - The aggregate function return type (a type that is supported
by SQLDataType)arguments - The aggregate function argumentsaggregate() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.name - The aggregate function name (possibly qualified)type - The aggregate function return typearguments - The aggregate function argumentsaggregateDistinct() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
aggregateDistinct(String, DataType, Field...).
name - The aggregate function name (possibly qualified)type - The aggregate function return type (a type that is supported
by SQLDataType)arguments - The aggregate function argumentsaggregateDistinct() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
name - The aggregate function nametype - The aggregate function return typearguments - The aggregate function argumentsaggregateDistinct() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
aggregateDistinct(Name, DataType, Field...).
name - The aggregate function name (possibly qualified)type - The aggregate function return type (a type that is supported
by SQLDataType)arguments - The aggregate function argumentsaggregateDistinct() can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.name - The aggregate function name (possibly qualified)type - The aggregate function return typearguments - The aggregate function argumentsThere must not be any bind variables contained in the SQL.
Example:
String sql = "(X = 1 and Y = 2)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLThere must not be any bind variables contained in the SQL.
Example:
String sql = "(X = 1 and Y = 2)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLThere must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example:
String sql = "(X = ? and Y = ?)";
Object[] bindings = new Object[] { 1, 2 };
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql - The SQLbindings - The bindings
This is useful for constructing more complex SQL syntax elements wherever
Condition types are expected. An example for this are
Postgres's various operators, some of which are missing in the jOOQ API.
For instance, the "overlap" operator for arrays:
ARRAY[1,4,3] && ARRAY[2,1]
The above Postgres operator can be expressed as such:
condition("{0} && {1}", array1, array2);
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses! One way to escape
literals is to use name(String...) and similar methods
sql - The SQLparts - The QueryPart objects that are rendered at the
{numbered placeholder} locationsDatabases that support boolean data types can use boolean expressions as predicates or as columns interchangeably. This extends to any type of field, including functions. A Postgres example:
select 1 where texteq('a', 'a');
value - The boolean expression.
The result is a condition generated from keys and values of the argument map, such that:
key1 = value1 AND key2 = value2 AND ... AND keyN = valueN
map - A map containing keys and values to form predicates.Condition from a Record
.
This will take all the non-null values in the argument
record to form a predicate from them. If all values in the
record are null, the predicate will be the
trueCondition().
record - The record from which to create a condition.Condition that behaves like no condition being
present.
This is useful as an "identity" condition for reduction operations, for
both AND and OR reductions, e.g.
Condition combined =
Stream.of(cond1, cond2, cond3)
.reduce(noCondition(), Condition::and);
When this condition is passed to SQL clauses, such as the
WHERE clause, the entire clause is omitted:
selectFrom(T).where(noCondition())
... will produce
SELECT * FROM t
NOTE [#16918] that this Condition is meant to be used with the
DSL API only, not with the QOM API, which cannot offer
any no-op operations. The behaviour when used with the QOM API is
undefined.
Condition that will always evaluate to
TRUE.Condition that will always evaluate to
FALSE.Condition that will always evaluate to
NULL.Condition that connects all argument
conditions with Operator.Condition that connects all argument
conditions with Operator.Condition that connects all argument
conditions with Operator.FIELD(expr, expr1, expr2, …) function.FIELD(expr, expr1, expr2, …) function.SelectField in a general-purpose FieldRowN as a SelectField directly, instead.Row1 as a SelectField directly, instead.Row2 as a SelectField directly, instead.Row3 as a SelectField directly, instead.Row4 as a SelectField directly, instead.Row5 as a SelectField directly, instead.Row6 as a SelectField directly, instead.Row7 as a SelectField directly, instead.Row8 as a SelectField directly, instead.Row9 as a SelectField directly, instead.Row10 as a SelectField directly, instead.Row11 as a SelectField directly, instead.Row12 as a SelectField directly, instead.Row13 as a SelectField directly, instead.Row14 as a SelectField directly, instead.Row15 as a SelectField directly, instead.Row16 as a SelectField directly, instead.Row17 as a SelectField directly, instead.Row18 as a SelectField directly, instead.Row19 as a SelectField directly, instead.Row20 as a SelectField directly, instead.Row21 as a SelectField directly, instead.Row22 as a SelectField directly, instead.IF(condition, ifTrue, ifFalse) function.IF(condition, ifTrue, ifFalse) function.IF(condition, ifTrue, ifFalse) function.IF(condition, ifTrue, ifFalse) function.Case statement.
Choose is used as a method name to avoid name clashes with Java's reserved literal "case"
Case statement.
This API can be used to create expressions of the type
CASE value WHEN 1 THEN 'one'
WHEN 2 THEN 'two'
ELSE 'three'
END
Choose is used as a method name to avoid name clashes with Java's reserved literal "case".
Case statement.
This API can be used to create expressions of the type
CASE value WHEN 1 THEN 'one'
WHEN 2 THEN 'two'
ELSE 'three'
END
Choose is used as a method name to avoid name clashes with Java's reserved literal "case".
CHOOSE() function.CHOOSE() function.CHOOSE() function.CHOOSE() function.Case statement.Case statement.
This API can be used to create expressions of the type
CASE value WHEN 1 THEN 'one'
WHEN 2 THEN 'two'
ELSE 'three'
END
Case statement.
This API can be used to create expressions of the type
CASE value WHEN 1 THEN 'one'
WHEN 2 THEN 'two'
ELSE 'three'
END
Case statement.
This API can be used to create expressions of the type
CASE WHEN x < 1 THEN 'one'
WHEN x >= 2 THEN 'two'
ELSE 'three'
END
Case statement.
This API can be used to create expressions of the type
CASE WHEN x < 1 THEN 'one'
WHEN x >= 2 THEN 'two'
ELSE 'three'
END
Case statement.
This API can be used to create expressions of the type
CASE WHEN x < 1 THEN 'one'
WHEN x >= 2 THEN 'two'
ELSE 'three'
END
Case statement.
This API can be used to create expressions of the type
CASE WHEN x < 1 THEN 'one'
WHEN x >= 2 THEN 'two'
ELSE 'three'
END
Case statement.
This API can be used to create expressions of the type
CASE WHEN x < 1 THEN 'one'
WHEN x >= 2 THEN 'two'
ELSE 'three'
END
Case statement.
This API can be used to create expressions of the type
CASE WHEN x < 1 THEN 'one'
WHEN x >= 2 THEN 'two'
ELSE 'three'
END
Case statement.
Decode is used as a method name to avoid name clashes with Java's reserved literal "case"
DECODE(expression, search, result[, search , result]… [, default])
function.DECODE(expression, search, result[, search , result]… [, default])
function.DECODE(expression, search, result[, search , result]… [, default])
function.DECODE(expression, search, result[, search , result]… [, default])
function.
Returns the dialect's equivalent to DECODE:
Other dialects:
CASE WHEN [this IS NOT DISTINCT FROM search] THEN [result],
[WHEN more... THEN more...]
[ELSE more...]
END
Note the use of the DISTINCT predicate to produce the same,
conveniently NULL-agnostic behaviour as Oracle.
value - The value to decodesearch - the mandatory first search parameterresult - the mandatory first result candidate parametermore - the optional parameters. If more.length is even,
then it is assumed that it contains more search/result pairs.
If more.length is odd, then it is assumed that it
contains more search/result pairs plus a default at the end.
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
coerce(Object, DataType).
value - The value to be coercedas - The field type (a type that is supported by
SQLDataType)
Unlike with casting, coercing doesn't affect the way the database sees a
Field's type. This is how coercing affects your SQL:
// This binds an int value to a JDBC PreparedStatement
DSL.val(1).coerce(String.class);
// This binds an int value to a JDBC PreparedStatement
// and casts it to VARCHAR in SQL
DSL.val(1).cast(String.class);
// This fetches a String value for the BOOK.ID field from JDBC
BOOK.ID.coerce(String.class);
// This fetches a String value for the BOOK.ID field from JDBC
// after casting it to VARCHAR in the database
BOOK.ID.cast(String.class);
T - The generic type of the coerced fieldfield - The field to be coercedas - The field whose type is used for the coercion
Unlike with casting, coercing doesn't affect the way the database sees a
Field's type. This is how coercing affects your SQL:
// This binds an int value to a JDBC PreparedStatement
DSL.val(1).coerce(String.class);
// This binds an int value to a JDBC PreparedStatement
// and casts it to VARCHAR in SQL
DSL.val(1).cast(String.class);
// This fetches a String value for the BOOK.ID field from JDBC
BOOK.ID.coerce(String.class);
// This fetches a String value for the BOOK.ID field from JDBC
// after casting it to VARCHAR in the database
BOOK.ID.cast(String.class);
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
coerce(Field, DataType).
T - The generic type of the coerced fieldas - The field type (a type that is supported by
SQLDataType)value - The value to be coerced
Unlike with casting, coercing doesn't affect the way the database sees a
Field's type. This is how coercing affects your SQL:
// This binds an int value to a JDBC PreparedStatement
DSL.val(1).coerce(String.class);
// This binds an int value to a JDBC PreparedStatement
// and casts it to VARCHAR in SQL
DSL.val(1).cast(String.class);
// This fetches a String value for the BOOK.ID field from JDBC
BOOK.ID.coerce(String.class);
// This fetches a String value for the BOOK.ID field from JDBC
// after casting it to VARCHAR in the database
BOOK.ID.cast(String.class);
T - The generic type of the coerced fieldfield - The field to be coercedas - The type that is used for the coercionCONVERT() function.T - The generic type of the converted fieldtype - The data type to convert tovalue - The expression to convertstyle - The style according to the SQL Server docsCONVERT() function.T - The generic type of the converted fieldtype - The data type to convert tovalue - The expression to convertstyle - The style according to the SQL Server docsT - The generic type of the cast fieldvalue - The value to castas - The field whose type is used for the castT - The generic type of the cast fieldfield - The field to castas - The field whose type is used for the castT - The generic type of the cast fieldas - The field whose type is used for the cast
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
cast(Object, DataType).
T - The generic type of the cast fieldvalue - The value to casttype - The type that is used for the cast (a type that is supported
by SQLDataType)
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
cast(Field, DataType).
T - The generic type of the cast fieldfield - The field to casttype - The type that is used for the cast (a type that is supported
by SQLDataType)T - The generic type of the cast fieldtype - The type that is used for the castT - The generic type of the cast fieldvalue - The value to casttype - The type that is used for the castT - The generic type of the cast fieldfield - The value to casttype - The type that is used for the cast
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
castNull(DataType).
T - The generic type of the cast fieldtype - The type that is used for the castCOALESCE(value1, value2, … , value n) function.COALESCE(field, value) function.COALESCE(field1, field2, … , field n) function.Returns the dialect's equivalent to NVL2:
Other dialects:
CASE WHEN [value] IS NULL THEN [valueIfNull] ELSE [valueIfNotNull] END
EXISTS function.NOT EXISTS function.NOT function.NOT function.UNIQUE function.NOT UNIQUE function.EXCLUDED function.
Provide "EXCLUDED" qualification for a column for use in ON CONFLICT or ON DUPLICATE KEY UPDATE.
field - The excluded field.ABS function.value - is wrapped as val(Object).ABS function.ACOS function.value - is wrapped as val(Object).ACOS function.ACOSH function.value - is wrapped as val(Object).ACOSH function.ACOTH function.value - is wrapped as val(Object).ACOTH function.ASIN function.value - is wrapped as val(Object).ASIN function.ASINH function.value - is wrapped as val(Object).ASINH function.ATAN function.value - is wrapped as val(Object).ATAN function.ATAN2 function.x - is wrapped as val(Object).y - is wrapped as val(Object).ATAN2 function.x - is wrapped as val(Object).ATAN2 function.y - is wrapped as val(Object).ATAN2 function.ATANH function.value - is wrapped as val(Object).ATANH function.BIT_AND function.arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).BIT_AND function.arg1 - is wrapped as val(Object).BIT_AND function.arg2 - is wrapped as val(Object).BIT_AND function.BIT_COUNT function.
Count the number of bits set in a number
value - is wrapped as val(Object).BIT_COUNT function.
Count the number of bits set in a number
BIT_GET function.bit - is wrapped as val(Object).BIT_GET function.BIT_NAND function.arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).BIT_NAND function.arg1 - is wrapped as val(Object).BIT_NAND function.arg2 - is wrapped as val(Object).BIT_NAND function.BIT_NOR function.arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).BIT_NOR function.arg1 - is wrapped as val(Object).BIT_NOR function.arg2 - is wrapped as val(Object).BIT_NOR function.BIT_NOT function.arg1 - is wrapped as val(Object).BIT_NOT function.BIT_OR function.arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).BIT_OR function.arg1 - is wrapped as val(Object).BIT_OR function.arg2 - is wrapped as val(Object).BIT_OR function.BIT_SET function.bit - is wrapped as val(Object).newValue - is wrapped as val(Object).BIT_SET function.bit - is wrapped as val(Object).BIT_SET function.newValue - is wrapped as val(Object).BIT_SET function.BIT_SET function.bit - is wrapped as val(Object).BIT_SET function.BIT_XNOR function.arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).BIT_XNOR function.arg1 - is wrapped as val(Object).BIT_XNOR function.arg2 - is wrapped as val(Object).BIT_XNOR function.BIT_XOR function.arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).BIT_XOR function.arg1 - is wrapped as val(Object).BIT_XOR function.arg2 - is wrapped as val(Object).BIT_XOR function.CEIL function.
Get the smallest integer value equal or greater to a value.
value - is wrapped as val(Object).CEIL function.
Get the smallest integer value equal or greater to a value.
COS function.value - is wrapped as val(Object).COS function.COSH function.value - is wrapped as val(Object).COSH function.COT function.value - is wrapped as val(Object).COT function.COTH function.value - is wrapped as val(Object).COTH function.DEGREES function.
Turn a value in radians to degrees.
radians - The value in radians.DEGREES function.
Turn a value in radians to degrees.
radians - The value in radians.E function.
The E literal (Euler number).
EXP function.value - is wrapped as val(Object).EXP function.FLOOR function.
Get the biggest integer value equal or less than a value.
value - is wrapped as val(Object).FLOOR function.
Get the biggest integer value equal or less than a value.
LN function.
Get the natural logarithm of a value.
value - is wrapped as val(Object).LN function.
Get the natural logarithm of a value.
LOG function.
Get the logarithm of a value for a base.
value - is wrapped as val(Object).base - is wrapped as val(Object).LOG function.
Get the logarithm of a value for a base.
value - is wrapped as val(Object).LOG function.
Get the logarithm of a value for a base.
base - is wrapped as val(Object).LOG function.
Get the logarithm of a value for a base.
LOG10 function.
Get the logarithm of a value for base 10.
value - is wrapped as val(Object).LOG10 function.
Get the logarithm of a value for base 10.
PI function.
The π literal.
POWER function.base - is wrapped as val(Object).exponent - is wrapped as val(Object).POWER function.base - is wrapped as val(Object).POWER function.exponent - is wrapped as val(Object).POWER function.RADIANS function.
Turn a value in degrees to radians.
degrees - The value in degrees.RADIANS function.
Turn a value in degrees to radians.
degrees - The value in degrees.RAND function.
Get a random numeric value.
ROUND function.
Round a numeric value to the nearest decimal precision.
value - The number to be rounded.decimals - The decimals to round to.ROUND function.
Round a numeric value to the nearest decimal precision.
value - The number to be rounded.decimals - The decimals to round to.ROUND function.
Round a numeric value to the nearest decimal precision.
value - The number to be rounded.decimals - The decimals to round to.ROUND function.
Round a numeric value to the nearest decimal precision.
value - The number to be rounded.decimals - The decimals to round to.ROUND function.
Round a numeric value to the nearest decimal precision.
value - The number to be rounded.ROUND function.
Round a numeric value to the nearest decimal precision.
value - The number to be rounded.SHL function.
Left shift all bits in a number
value - The number whose bits to shift left.count - The number of bits to shift.SHL function.
Left shift all bits in a number
value - The number whose bits to shift left.count - The number of bits to shift.SHL function.
Left shift all bits in a number
value - The number whose bits to shift left.count - The number of bits to shift.SHL function.
Left shift all bits in a number
value - The number whose bits to shift left.count - The number of bits to shift.SHR function.
Right shift all bits in a number
value - The number whose bits to shift rightcount - The number of bits to shift.SHR function.
Right shift all bits in a number
value - The number whose bits to shift rightcount - The number of bits to shift.SHR function.
Right shift all bits in a number
value - The number whose bits to shift rightcount - The number of bits to shift.SHR function.
Right shift all bits in a number
value - The number whose bits to shift rightcount - The number of bits to shift.SIGN function.
Get the sign of a number and return it as any of +1, 0, -1.
value - is wrapped as val(Object).SIGN function.
Get the sign of a number and return it as any of +1, 0, -1.
SIN function.value - is wrapped as val(Object).SIN function.SINH function.value - is wrapped as val(Object).SINH function.SQRT function.value - is wrapped as val(Object).SQRT function.SQUARE function.value - is wrapped as val(Object).SQUARE function.TAN function.value - is wrapped as val(Object).TAN function.TANH function.value - is wrapped as val(Object).TANH function.TAU function.
The τ literal, or π, in a better world.
TRUNC function.
Truncate a number to a given number of decimals.
value - The number to be truncateddecimals - The decimals to truncate to.TRUNC function.
Truncate a number to a given number of decimals.
value - The number to be truncateddecimals - The decimals to truncate to.TRUNC function.
Truncate a number to a given number of decimals.
value - The number to be truncateddecimals - The decimals to truncate to.TRUNC function.
Truncate a number to a given number of decimals.
value - The number to be truncateddecimals - The decimals to truncate to.WIDTH_BUCKET function.
Divide a range into buckets of equal size.
field - The value to divide into the range.low - The lower bound of the range.high - The upper bound of the range.buckets - The number of buckets to produce.WIDTH_BUCKET function.
Divide a range into buckets of equal size.
field - The value to divide into the range.low - The lower bound of the range.high - The upper bound of the range.buckets - The number of buckets to produce.ASCII function.
The ASCII value of a character.
string - is wrapped as val(Object).ASCII function.
The ASCII value of a character.
BIT_LENGTH function.
The length of a string in bits.
string - is wrapped as val(Object).BIT_LENGTH function.
The length of a string in bits.
CHAR_LENGTH function.
The length of a string in characters.
string - is wrapped as val(Object).CHAR_LENGTH function.
The length of a string in characters.
CHR function.value - is wrapped as val(Object).CHR function.DIGITS function.value - is wrapped as val(Object).DIGITS function.LEFT function.
Get the left outermost characters from a string.
string - The string whose characters are extracted.length - The number of characters to extract from the string.LEFT function.
Get the left outermost characters from a string.
string - The string whose characters are extracted.length - The number of characters to extract from the string.LEFT function.
Get the left outermost characters from a string.
string - The string whose characters are extracted.length - The number of characters to extract from the string.LEFT function.
Get the left outermost characters from a string.
string - The string whose characters are extracted.length - The number of characters to extract from the string.LENGTH function, an alias for the CHAR_LENGTH function.
The length of a string in characters.
string - is wrapped as val(Object).LENGTH function, an alias for the CHAR_LENGTH function.
The length of a string in characters.
LOWER function.
Turn a string into lower case.
string - is wrapped as val(Object).LOWER function.
Turn a string into lower case.
LPAD function.
Left-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.character - The padding character, if different from whitespaceLPAD function.
Left-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.character - The padding character, if different from whitespaceLPAD function.
Left-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.character - The padding character, if different from whitespaceLPAD function.
Left-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.character - The padding character, if different from whitespaceLPAD function.
Left-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.LPAD function.
Left-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.LTRIM function.
Trim characters (whitespace as default) from the left side of a string.
string - The string to be trimmed.characters - The characters to be trimmed.LTRIM function.
Trim characters (whitespace as default) from the left side of a string.
string - The string to be trimmed.characters - The characters to be trimmed.LTRIM function.
Trim characters (whitespace as default) from the left side of a string.
string - The string to be trimmed.characters - The characters to be trimmed.LTRIM function.
Trim characters (whitespace as default) from the left side of a string.
string - The string to be trimmed.characters - The characters to be trimmed.LTRIM function.
Trim characters (whitespace as default) from the left side of a string.
string - The string to be trimmed.LTRIM function.
Trim characters (whitespace as default) from the left side of a string.
string - The string to be trimmed.MD5 function.
Calculate an MD5 hash from a string.
string - is wrapped as val(Object).MD5 function.
Calculate an MD5 hash from a string.
MID function, an alias for the SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.length - The maximum length of the substring.MID function, an alias for the SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.length - The maximum length of the substring.MID function, an alias for the SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.length - The maximum length of the substring.MID function, an alias for the SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.length - The maximum length of the substring.MID function, an alias for the SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.MID function, an alias for the SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.OCTET_LENGTH function.
The length of a string in octets.
string - is wrapped as val(Object).OCTET_LENGTH function.
The length of a string in octets.
OVERLAY function.
Place a string on top of another string, replacing the original contents.
in - The original string on top of which the overlay is placed.placing - The string that is being placed on top of the other string.startIndex - The start index (1-based) starting from where the overlay is placed.length - The length in the original string that will be replaced, if different from the overlay length.OVERLAY function.
Place a string on top of another string, replacing the original contents.
in - The original string on top of which the overlay is placed.placing - The string that is being placed on top of the other string.startIndex - The start index (1-based) starting from where the overlay is placed.length - The length in the original string that will be replaced, if different from the overlay length.OVERLAY function.
Place a string on top of another string, replacing the original contents.
in - The original string on top of which the overlay is placed.placing - The string that is being placed on top of the other string.startIndex - The start index (1-based) starting from where the overlay is placed.OVERLAY function.
Place a string on top of another string, replacing the original contents.
in - The original string on top of which the overlay is placed.placing - The string that is being placed on top of the other string.startIndex - The start index (1-based) starting from where the overlay is placed.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.startIndex - The start index (1-based) from which to start looking for the substring.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.startIndex - The start index (1-based) from which to start looking for the substring.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.startIndex - The start index (1-based) from which to start looking for the substring.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.startIndex - The start index (1-based) from which to start looking for the substring.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.startIndex - The start index (1-based) from which to start looking for the substring.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.startIndex - The start index (1-based) from which to start looking for the substring.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.startIndex - The start index (1-based) from which to start looking for the substring.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.startIndex - The start index (1-based) from which to start looking for the substring.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.POSITION function.
Search the position (1-based) of a substring in another string.
in - The string in which to search the substring.search - The substring to search for.REPEAT function.
Repeat a string a number of times.
string - The string to be repeated.count - The number of times to repeat the string.REPEAT function.
Repeat a string a number of times.
string - The string to be repeated.count - The number of times to repeat the string.REPEAT function.
Repeat a string a number of times.
string - The string to be repeated.count - The number of times to repeat the string.REPEAT function.
Repeat a string a number of times.
string - The string to be repeated.count - The number of times to repeat the string.REPLACE function.
Replace all occurrences of a substring in another string.
string - The string in which to replace contents.search - The substring to search for.replace - The replacement for each substring, if not empty.REPLACE function.
Replace all occurrences of a substring in another string.
string - The string in which to replace contents.search - The substring to search for.replace - The replacement for each substring, if not empty.REPLACE function.
Replace all occurrences of a substring in another string.
string - The string in which to replace contents.search - The substring to search for.replace - The replacement for each substring, if not empty.REPLACE function.
Replace all occurrences of a substring in another string.
string - The string in which to replace contents.search - The substring to search for.replace - The replacement for each substring, if not empty.REPLACE function.
Replace all occurrences of a substring in another string.
string - The string in which to replace contents.search - The substring to search for.REPLACE function.
Replace all occurrences of a substring in another string.
string - The string in which to replace contents.search - The substring to search for.REVERSE function.
Reverse a string.
string - is wrapped as val(Object).REVERSE function.
Reverse a string.
RIGHT function.
Get the right outermost characters from a string.
string - The string whose characters are extracted.length - The number of characters to extract from the string.RIGHT function.
Get the right outermost characters from a string.
string - The string whose characters are extracted.length - The number of characters to extract from the string.RIGHT function.
Get the right outermost characters from a string.
string - The string whose characters are extracted.length - The number of characters to extract from the string.RIGHT function.
Get the right outermost characters from a string.
string - The string whose characters are extracted.length - The number of characters to extract from the string.RPAD function.
Right-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.character - The padding character, if different from whitespaceRPAD function.
Right-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.character - The padding character, if different from whitespaceRPAD function.
Right-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.character - The padding character, if different from whitespaceRPAD function.
Right-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.character - The padding character, if different from whitespaceRPAD function.
Right-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.RPAD function.
Right-pad a string with a character (whitespace as default) for a number of times.
string - The string to be padded.length - The maximum length to pad the string to.RTRIM function.
Trim characters (whitespace as default) from the right side of a string.
string - The string to be trimmed.characters - The characters to be trimmed.RTRIM function.
Trim characters (whitespace as default) from the right side of a string.
string - The string to be trimmed.characters - The characters to be trimmed.RTRIM function.
Trim characters (whitespace as default) from the right side of a string.
string - The string to be trimmed.characters - The characters to be trimmed.RTRIM function.
Trim characters (whitespace as default) from the right side of a string.
string - The string to be trimmed.characters - The characters to be trimmed.RTRIM function.
Trim characters (whitespace as default) from the right side of a string.
string - The string to be trimmed.RTRIM function.
Trim characters (whitespace as default) from the right side of a string.
string - The string to be trimmed.SPACE function.
Get a string of spaces of a given length.
count - The number of spaces to produce.SPACE function.
Get a string of spaces of a given length.
count - The number of spaces to produce.SPLIT_PART function.
Split a string into tokens, and retrieve the nth token.
string - The string to be split into parts.delimiter - The delimiter used for splitting.n - The token number (1-based).SPLIT_PART function.
Split a string into tokens, and retrieve the nth token.
string - The string to be split into parts.delimiter - The delimiter used for splitting.n - The token number (1-based).SPLIT_PART function.
Split a string into tokens, and retrieve the nth token.
string - The string to be split into parts.delimiter - The delimiter used for splitting.n - The token number (1-based).SPLIT_PART function.
Split a string into tokens, and retrieve the nth token.
string - The string to be split into parts.delimiter - The delimiter used for splitting.n - The token number (1-based).SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.length - The maximum length of the substring.SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.length - The maximum length of the substring.SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.length - The maximum length of the substring.SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.length - The maximum length of the substring.SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.SUBSTRING function.
Get a substring of a string, from a given position.
string - The string from which to get the substring.startingPosition - The position (1-based) from which to get the substring.SUBSTRING_INDEX function.
Get a substring of a string, from the beginning until the nth occurrence of a substring.
string - The string from which to get the substring.delimiter - The delimiter.n - The number of occurrences of the delimiter.SUBSTRING_INDEX function.
Get a substring of a string, from the beginning until the nth occurrence of a substring.
string - The string from which to get the substring.delimiter - The delimiter.n - The number of occurrences of the delimiter.SUBSTRING_INDEX function.
Get a substring of a string, from the beginning until the nth occurrence of a substring.
string - The string from which to get the substring.delimiter - The delimiter.n - The number of occurrences of the delimiter.SUBSTRING_INDEX function.
Get a substring of a string, from the beginning until the nth occurrence of a substring.
string - The string from which to get the substring.delimiter - The delimiter.n - The number of occurrences of the delimiter.TO_CHAR function.
Format an arbitrary value as a string.
value - The value to be formatted.formatMask - The vendor-specific formatting string.TO_CHAR function.
Format an arbitrary value as a string.
value - The value to be formatted.formatMask - The vendor-specific formatting string.TO_CHAR function.
Format an arbitrary value as a string.
value - The value to be formatted.formatMask - The vendor-specific formatting string.TO_CHAR function.
Format an arbitrary value as a string.
value - The value to be formatted.formatMask - The vendor-specific formatting string.TO_CHAR function.
Format an arbitrary value as a string.
value - The value to be formatted.TO_CHAR function.
Format an arbitrary value as a string.
value - The value to be formatted.TO_DATE function.
Parse a string-formatted date value to a date.
value - The formatted DATE value.formatMask - The vendor-specific formatting string.TO_DATE function.
Parse a string-formatted date value to a date.
value - The formatted DATE value.formatMask - The vendor-specific formatting string.TO_DATE function.
Parse a string-formatted date value to a date.
value - The formatted DATE value.formatMask - The vendor-specific formatting string.TO_DATE function.
Parse a string-formatted date value to a date.
value - The formatted DATE value.formatMask - The vendor-specific formatting string.TO_HEX function.
Format a number to its hex value.
value - is wrapped as val(Object).TO_HEX function.
Format a number to its hex value.
TO_TIMESTAMP function.
Parse a string-formatted timestamp value to a timestamp.
value - The formatted TIMESTAMP value.formatMask - The vendor-specific formatting string.TO_TIMESTAMP function.
Parse a string-formatted timestamp value to a timestamp.
value - The formatted TIMESTAMP value.formatMask - The vendor-specific formatting string.TO_TIMESTAMP function.
Parse a string-formatted timestamp value to a timestamp.
value - The formatted TIMESTAMP value.formatMask - The vendor-specific formatting string.TO_TIMESTAMP function.
Parse a string-formatted timestamp value to a timestamp.
value - The formatted TIMESTAMP value.formatMask - The vendor-specific formatting string.TRANSLATE function.
Translate a set of characters to another set of characters in a string.
string - The string to translate.from - The set of source characters.to - The set of target characters, matched with source characters by position.TRANSLATE function.
Translate a set of characters to another set of characters in a string.
string - The string to translate.from - The set of source characters.to - The set of target characters, matched with source characters by position.TRANSLATE function.
Translate a set of characters to another set of characters in a string.
string - The string to translate.from - The set of source characters.to - The set of target characters, matched with source characters by position.TRANSLATE function.
Translate a set of characters to another set of characters in a string.
string - The string to translate.from - The set of source characters.to - The set of target characters, matched with source characters by position.TRIM function.
Trim characters (whitespace as default) from both sides of a string.
string - The string to be trimmed.characters - The characters to be trimmed.TRIM function.
Trim characters (whitespace as default) from both sides of a string.
string - The string to be trimmed.characters - The characters to be trimmed.TRIM function.
Trim characters (whitespace as default) from both sides of a string.
string - The string to be trimmed.characters - The characters to be trimmed.TRIM function.
Trim characters (whitespace as default) from both sides of a string.
string - The string to be trimmed.characters - The characters to be trimmed.TRIM function.
Trim characters (whitespace as default) from both sides of a string.
string - The string to be trimmed.TRIM function.
Trim characters (whitespace as default) from both sides of a string.
string - The string to be trimmed.UPPER function.
Turn a string into upper case.
string - is wrapped as val(Object).UPPER function.
Turn a string into upper case.
UUID function.
Generate a random UUID.
DATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the datedatePart - The date part describing the intervalDATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the datedatePart - The date part describing the intervalDATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the datedatePart - The date part describing the intervalDATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the datedatePart - The date part describing the intervalDATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the dateDATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the dateDATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the dateDATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the dateLOCAL_DATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the datedatePart - The date part describing the intervalLOCAL_DATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the datedatePart - The date part describing the intervalLOCAL_DATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the datedatePart - The date part describing the intervalLOCAL_DATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the datedatePart - The date part describing the intervalLOCAL_DATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the dateLOCAL_DATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the dateLOCAL_DATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the dateLOCAL_DATE_ADD function.
Add an interval to a date.
date - The date to add an interval tointerval - The interval to add to the dateTIMESTAMP_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampdatePart - The date part describing the intervalTIMESTAMP_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampdatePart - The date part describing the intervalTIMESTAMP_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampdatePart - The date part describing the intervalTIMESTAMP_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampdatePart - The date part describing the intervalTIMESTAMP_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampTIMESTAMP_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampTIMESTAMP_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampTIMESTAMP_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampLOCAL_DATE_TIME_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampdatePart - The date part describing the intervalLOCAL_DATE_TIME_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampdatePart - The date part describing the intervalLOCAL_DATE_TIME_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampdatePart - The date part describing the intervalLOCAL_DATE_TIME_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampdatePart - The date part describing the intervalLOCAL_DATE_TIME_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampLOCAL_DATE_TIME_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampLOCAL_DATE_TIME_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampLOCAL_DATE_TIME_ADD function.
Add an interval to a timestamp.
date - The timestamp to add an interval tointerval - The interval to add to the timestampCARDINALITY function.
Calculate the cardinality of an array field.
ARRAY_GET function.
Get an array element at a given index (1 based).
index - is wrapped as val(Object).ARRAY_GET function.
Get an array element at a given index (1 based).
ARRAY_CONCAT function.
Concatenate two arrays.
ARRAY_CONCAT function.
Concatenate two arrays.
ARRAY_CONCAT function.
Concatenate two arrays.
ARRAY_CONCAT function.
Concatenate two arrays.
ARRAY_APPEND function.
Append an element to an array.
arg2 - is wrapped as val(Object).ARRAY_APPEND function.
Append an element to an array.
ARRAY_APPEND function.
Append an element to an array.
arg2 - is wrapped as val(Object).ARRAY_APPEND function.
Append an element to an array.
ARRAY_PREPEND function.
Prepend an element to an array.
arg1 - is wrapped as val(Object).ARRAY_PREPEND function.
Prepend an element to an array.
arg1 - is wrapped as val(Object).ARRAY_PREPEND function.
Prepend an element to an array.
ARRAY_PREPEND function.
Prepend an element to an array.
ARRAY_OVERLAP function.
Check if 2 arrays overlap.
ARRAY_OVERLAP function.
Check if 2 arrays overlap.
ARRAY_OVERLAP function.
Check if 2 arrays overlap.
ARRAY_OVERLAP function.
Check if 2 arrays overlap.
ARRAY_REMOVE function.
Remove an element from an array.
arg2 - is wrapped as val(Object).ARRAY_REMOVE function.
Remove an element from an array.
ARRAY_REMOVE function.
Remove an element from an array.
arg2 - is wrapped as val(Object).ARRAY_REMOVE function.
Remove an element from an array.
ARRAY_REPLACE function.
Replace an element in an array.
arg2 - is wrapped as val(Object).arg3 - is wrapped as val(Object).ARRAY_REPLACE function.
Replace an element in an array.
NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.ISNULL function, an alias for the NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.ISNULL function, an alias for the NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.ISNULL function, an alias for the NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.ISNULL function, an alias for the NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.IFNULL function, an alias for the NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.IFNULL function, an alias for the NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.IFNULL function, an alias for the NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.IFNULL function, an alias for the NVL function.
Return the first non-null argument.
value - The nullable value.defaultValue - The default value if the other value is null.NULLIF function.value - The result value if the other value is not equal.other - The value to compare the result value with.NULLIF function.value - The result value if the other value is not equal.other - The value to compare the result value with.NULLIF function.value - The result value if the other value is not equal.other - The value to compare the result value with.NULLIF function.value - The result value if the other value is not equal.other - The value to compare the result value with.TRY_CAST function.value - The value to be cast to a data typedataType - The data type to try to cast the value toTRY_CAST function.value - The value to be cast to a data typedataType - The data type to try to cast the value toCURRENT_CATALOG function.CURRENT_SCHEMA function.CURRENT_USER function.CONNECT_BY_ISCYCLE function.
The CONNECT_BY_ISCYCLE pseudo column is used with the Oracle style CONNECT BY clause.
CONNECT_BY_ISLEAF function.
The CONNECT_BY_ISLEAF pseudo column is used with the Oracle style CONNECT BY clause.
CONNECT_BY_ROOT function.
The CONNECT_BY_ROOT operator is used with the Oracle style CONNECT BY clause.
LEVEL function.
The LEVEL pseudo column is used with the Oracle style CONNECT BY clause.
PRIOR function.
The PRIOR operator is used with the Oracle style CONNECT BY clause.
SYS_CONNECT_BY_PATH function.
The SYS_CONNECT_BY_PATH function is used with the Oracle style CONNECT BY clause.
ROWNUM function.
Depending on its usage, the Oracle-specific ROWNUM pseudo-field can
be emulated using LIMIT or ROW_NUMBER().
XMLCOMMENT function.comment - is wrapped as val(Object).XMLCOMMENT function.XMLCONCAT function.XMLCONCAT function.XMLDOCUMENT function.XMLFOREST function.XMLFOREST function.XMLPI function.XMLPI function.XMLPI function.XMLPI function.XMLSERIALIZE function.value - is wrapped as val(Object).XMLSERIALIZE function.XMLSERIALIZE_CONTENT function.value - is wrapped as val(Object).XMLSERIALIZE_CONTENT function.JSON_ARRAY function.JSON_ARRAY function.JSONB_ARRAY function.JSONB_ARRAY function.JSON_OBJECT function.JSON_OBJECT function.JSONB_OBJECT function.JSONB_OBJECT function.JSON_GET_ELEMENT function.
Access an array element from a JSON array expression.
field - The JSON documentindex - The 0-based JSON array indexJSON_GET_ELEMENT function.
Access an array element from a JSON array expression.
field - The JSON documentindex - The 0-based JSON array indexJSON_GET_ELEMENT function.
Access an array element from a JSON array expression.
field - The JSON documentindex - The 0-based JSON array indexJSON_GET_ELEMENT function.
Access an array element from a JSON array expression.
field - The JSON documentindex - The 0-based JSON array indexJSONB_GET_ELEMENT function.
Access an array element from a JSONB array expression.
field - The JSONB documentindex - The 0-based JSONB array indexJSONB_GET_ELEMENT function.
Access an array element from a JSONB array expression.
field - The JSONB documentindex - The 0-based JSONB array indexJSONB_GET_ELEMENT function.
Access an array element from a JSONB array expression.
field - The JSONB documentindex - The 0-based JSONB array indexJSONB_GET_ELEMENT function.
Access an array element from a JSONB array expression.
field - The JSONB documentindex - The 0-based JSONB array indexJSON_GET_ELEMENT_AS_TEXT function.
Access an array element from a JSON array expression and return it as a string.
field - The JSON documentindex - The 0-based JSON array indexJSON_GET_ELEMENT_AS_TEXT function.
Access an array element from a JSON array expression and return it as a string.
field - The JSON documentindex - The 0-based JSON array indexJSON_GET_ELEMENT_AS_TEXT function.
Access an array element from a JSON array expression and return it as a string.
field - The JSON documentindex - The 0-based JSON array indexJSON_GET_ELEMENT_AS_TEXT function.
Access an array element from a JSON array expression and return it as a string.
field - The JSON documentindex - The 0-based JSON array indexJSONB_GET_ELEMENT_AS_TEXT function.
Access an array element from a JSONB array expression and return it as a string.
field - The JSONB documentindex - The 0-based JSONB array indexJSONB_GET_ELEMENT_AS_TEXT function.
Access an array element from a JSONB array expression and return it as a string.
field - The JSONB documentindex - The 0-based JSONB array indexJSONB_GET_ELEMENT_AS_TEXT function.
Access an array element from a JSONB array expression and return it as a string.
field - The JSONB documentindex - The 0-based JSONB array indexJSONB_GET_ELEMENT_AS_TEXT function.
Access an array element from a JSONB array expression and return it as a string.
field - The JSONB documentindex - The 0-based JSONB array indexJSON_GET_ATTRIBUTE function.
Access an object attribute value from a JSON object expression.
field - The JSON documentattribute - The JSON object attribute nameJSON_GET_ATTRIBUTE function.
Access an object attribute value from a JSON object expression.
field - The JSON documentattribute - The JSON object attribute nameJSON_GET_ATTRIBUTE function.
Access an object attribute value from a JSON object expression.
field - The JSON documentattribute - The JSON object attribute nameJSON_GET_ATTRIBUTE function.
Access an object attribute value from a JSON object expression.
field - The JSON documentattribute - The JSON object attribute nameJSONB_GET_ATTRIBUTE function.
Access an object attribute value from a JSONB object expression.
field - The JSONB documentattribute - The JSONB object attribute nameJSONB_GET_ATTRIBUTE function.
Access an object attribute value from a JSONB object expression.
field - The JSONB documentattribute - The JSONB object attribute nameJSONB_GET_ATTRIBUTE function.
Access an object attribute value from a JSONB object expression.
field - The JSONB documentattribute - The JSONB object attribute nameJSONB_GET_ATTRIBUTE function.
Access an object attribute value from a JSONB object expression.
field - The JSONB documentattribute - The JSONB object attribute nameJSON_GET_ATTRIBUTE_AS_TEXT function.
Access an object attribute value from a JSON object expression and return it as string.
field - The JSON documentattribute - The JSON object attribute nameJSON_GET_ATTRIBUTE_AS_TEXT function.
Access an object attribute value from a JSON object expression and return it as string.
field - The JSON documentattribute - The JSON object attribute nameJSON_GET_ATTRIBUTE_AS_TEXT function.
Access an object attribute value from a JSON object expression and return it as string.
field - The JSON documentattribute - The JSON object attribute nameJSON_GET_ATTRIBUTE_AS_TEXT function.
Access an object attribute value from a JSON object expression and return it as string.
field - The JSON documentattribute - The JSON object attribute nameJSONB_GET_ATTRIBUTE_AS_TEXT function.
Access an object attribute value from a JSONB object expression and return it as string.
field - The JSONB documentattribute - The JSONB object attribute nameJSONB_GET_ATTRIBUTE_AS_TEXT function.
Access an object attribute value from a JSONB object expression and return it as string.
field - The JSONB documentattribute - The JSONB object attribute nameJSONB_GET_ATTRIBUTE_AS_TEXT function.
Access an object attribute value from a JSONB object expression and return it as string.
field - The JSONB documentattribute - The JSONB object attribute nameJSONB_GET_ATTRIBUTE_AS_TEXT function.
Access an object attribute value from a JSONB object expression and return it as string.
field - The JSONB documentattribute - The JSONB object attribute nameJSON_KEYS function.
Retrieve all keys from a JSON object as an array of strings.
field - is wrapped as val(Object).JSON_KEYS function.
Retrieve all keys from a JSON object as an array of strings.
JSONB_KEYS function.
Retrieve all keys from a JSONB object as an array of strings.
field - is wrapped as val(Object).JSONB_KEYS function.
Retrieve all keys from a JSONB object as an array of strings.
JSON_SET function.
Add or replace a JSON value to a JSON field at a given path.
path - is wrapped as val(Object).value - is wrapped as val(Object).JSON_SET function.
Add or replace a JSON value to a JSON field at a given path.
path - is wrapped as val(Object).JSON_SET function.
Add or replace a JSON value to a JSON field at a given path.
value - is wrapped as val(Object).JSON_SET function.
Add or replace a JSON value to a JSON field at a given path.
JSONB_SET function.
Add or replace a JSONB value to a JSONB field at a given path.
path - is wrapped as val(Object).value - is wrapped as val(Object).JSONB_SET function.
Add or replace a JSONB value to a JSONB field at a given path.
path - is wrapped as val(Object).JSONB_SET function.
Add or replace a JSONB value to a JSONB field at a given path.
value - is wrapped as val(Object).JSONB_SET function.
Add or replace a JSONB value to a JSONB field at a given path.
JSON_INSERT function.
Add (but not replace) a JSON value to a JSON field at a given path.
path - is wrapped as val(Object).value - is wrapped as val(Object).JSON_INSERT function.
Add (but not replace) a JSON value to a JSON field at a given path.
path - is wrapped as val(Object).JSON_INSERT function.
Add (but not replace) a JSON value to a JSON field at a given path.
value - is wrapped as val(Object).JSON_INSERT function.
Add (but not replace) a JSON value to a JSON field at a given path.
JSONB_INSERT function.
Add (but not replace) a JSON value to a JSON field at a given path.
path - is wrapped as val(Object).value - is wrapped as val(Object).JSONB_INSERT function.
Add (but not replace) a JSON value to a JSON field at a given path.
path - is wrapped as val(Object).JSONB_INSERT function.
Add (but not replace) a JSON value to a JSON field at a given path.
value - is wrapped as val(Object).JSONB_INSERT function.
Add (but not replace) a JSON value to a JSON field at a given path.
JSON_REPLACE function.
Replace (but not add) a JSON value to a JSON field at a given path.
path - is wrapped as val(Object).value - is wrapped as val(Object).JSON_REPLACE function.
Replace (but not add) a JSON value to a JSON field at a given path.
path - is wrapped as val(Object).JSON_REPLACE function.
Replace (but not add) a JSON value to a JSON field at a given path.
value - is wrapped as val(Object).JSON_REPLACE function.
Replace (but not add) a JSON value to a JSON field at a given path.
JSONB_REPLACE function.
Replace (but not add) a JSONB value to a JSONB field at a given path.
path - is wrapped as val(Object).value - is wrapped as val(Object).JSONB_REPLACE function.
Replace (but not add) a JSONB value to a JSONB field at a given path.
path - is wrapped as val(Object).JSONB_REPLACE function.
Replace (but not add) a JSONB value to a JSONB field at a given path.
value - is wrapped as val(Object).JSONB_REPLACE function.
Replace (but not add) a JSONB value to a JSONB field at a given path.
JSON_REMOVE function.
Remove a JSON value from a JSON field at a given path.
path - is wrapped as val(Object).JSON_REMOVE function.
Remove a JSON value from a JSON field at a given path.
JSONB_REMOVE function.
Remove a JSONB value from a JSONB field at a given path.
path - is wrapped as val(Object).JSONB_REMOVE function.
Remove a JSONB value from a JSONB field at a given path.
DELETING function.INSERTING function.UPDATING function.FIELD function.
Wrap a condition in a boolean field.
CONDITION function.
Create a condition from a boolean field.
Databases that support boolean data types can use boolean expressions as predicates or as columns interchangeably. This extends to any type of field, including functions. A Postgres example:
select 1 where texteq('a', 'a');
ANY_VALUE function.
Get any arbitrary value from the group.
AVG function.AVG_DISTINCT function.BIT_AND_AGG function.
Calculate the bitwise AND aggregate value.
BIT_OR_AGG function.
Calculate the bitwise OR aggregate value.
BIT_XOR_AGG function.
Calculate the bitwise XOR aggregate value.
BIT_NAND_AGG function.
Calculate the bitwise NAND aggregate value.
BIT_NOR_AGG function.
Calculate the bitwise NOR aggregate value.
BIT_XNOR_AGG function.
Calculate the bitwise XNOR aggregate value.
BOOL_AND function.BOOL_AND function.BOOL_OR function.BOOL_OR function.CORR function.
Calculate the correlation coefficient. This standard SQL function may be supported
natively, or emulated using covarPop(Field, Field) and stddevPop(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
COUNT function.COUNT_DISTINCT function.COVAR_SAMP function.
Calculate the sample covariance. This standard SQL function may be supported natively,
or emulated using sum(Field) and count(Field). If an emulation
is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
COVAR_POP function.
Calculate the population covariance. This standard SQL function may be supported
natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
EVERY function, an alias for the BOOL_AND function.EVERY function, an alias for the BOOL_AND function.MAX function.MAX_DISTINCT function.MEDIAN function.MIN function.MIN_DISTINCT function.PRODUCT function.
Get the sum over a numeric field: product(distinct field).
Few dialects currently support multiplicative aggregation natively. jOOQ
emulates this using exp(sum(log(arg))) for strictly positive
numbers, and does some additional handling for zero and negative numbers.
Note that this implementation may introduce rounding errors, even for integer multiplication.
More information here: https://blog.jooq.org/how-to-write-a-multiplication-aggregate-function-in-sql.
PRODUCT_DISTINCT function.
Get the sum over a numeric field: product(distinct field).
Few dialects currently support multiplicative aggregation natively. jOOQ
emulates this using exp(sum(log(arg))) for strictly positive
numbers, and does some additional handling for zero and negative numbers.
Note that this implementation may introduce rounding errors, even for integer multiplication.
More information here: https://blog.jooq.org/how-to-write-a-multiplication-aggregate-function-in-sql.
REGR_AVGX function.
Calculate the average of the independent values (x). This standard SQL function may
be supported natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_AVGY function.
Calculate the average of the dependent values (y). This standard SQL function may
be supported natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_COUNT function.
Calculate the number of non-NULL pairs. This standard SQL function may
be supported natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_INTERCEPT function.
Calculate the y intercept of the regression line. This standard SQL function may
be supported natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_R2 function.
Calculate the coefficient of determination. This standard SQL function may be supported
natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_SLOPE function.
Calculate the slope of the regression line. This standard SQL function may be supported
natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_SXX function.
Calculate the REGR_SXX auxiliary function. This standard SQL function
may be supported natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_SXY function.
Calculate the REGR_SXY auxiliary function. This standard SQL function
may be supported natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_SYY function.
Calculate the REGR_SYY auxiliary function. This standard SQL function
may be supported natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
STDDEV_POP function.
Calculate the population standard deviation. This standard SQL function may be supported
natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
STDDEV_SAMP function.
Calculate the sample standard deviation. This standard SQL function may be supported
natively, or emulated using sum(Field) and count(Field).
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
SUM function.SUM_DISTINCT function.VAR_POP function.
Calculate the population variance. This standard SQL function may be supported natively,
or emulated using sum(Field) and count(Field). If an emulation
is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
VAR_SAMP function.
Calculate the sample variance. This standard SQL function may be supported natively,
or emulated using sum(Field) and count(Field). If an emulation
is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
GOTO function.EXECUTE function.
Execute a statement dynamically from within procedural code.
Many dialects support some way of running procedural and SQL statements dynamically from within procedural code. For example, in Oracle, this syntax is required to run DDL statements from PL/SQL:
BEGIN
EXECUTE IMMEDIATE 'CREATE TABLE x (i INT)';
END;
sql - is wrapped as val(Object).EXECUTE function.
Execute a statement dynamically from within procedural code.
Many dialects support some way of running procedural and SQL statements dynamically from within procedural code. For example, in Oracle, this syntax is required to run DDL statements from PL/SQL:
BEGIN
EXECUTE IMMEDIATE 'CREATE TABLE x (i INT)';
END;
RETURN_ function.value - is wrapped as val(Object).RETURN_ function.RETURN_ function.SIGNAL_SQLSTATE function.value - is wrapped as val(Object).SIGNAL_SQLSTATE function.ST_AREA function.
Calculate the area from a spatial type.
value - is wrapped as val(Object).ST_AREA function.
Calculate the area from a spatial type.
ST_ASBINARY function.
Create a WKB representation from a spatial type.
value - is wrapped as val(Object).ST_ASBINARY function.
Create a WKB representation from a spatial type.
ST_ASTEXT function.
Create a text representation from a spatial type.
value - is wrapped as val(Object).ST_ASTEXT function.
Create a text representation from a spatial type.
ST_CENTROID function.
Get the geometric center of a spatial value.
value - is wrapped as val(Object).ST_CENTROID function.
Get the geometric center of a spatial value.
ST_CONTAINS function.
Check if a spatial value contains another.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_CONTAINS function.
Check if a spatial value contains another.
arg1 - is wrapped as val(Object).ST_CONTAINS function.
Check if a spatial value contains another.
arg2 - is wrapped as val(Object).ST_CONTAINS function.
Check if a spatial value contains another.
ST_CROSSES function.
Check if a geometry crosses another.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_CROSSES function.
Check if a geometry crosses another.
arg1 - is wrapped as val(Object).ST_CROSSES function.
Check if a geometry crosses another.
arg2 - is wrapped as val(Object).ST_CROSSES function.
Check if a geometry crosses another.
ST_DIFFERENCE function.
Get the difference of two spatial values.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_DIFFERENCE function.
Get the difference of two spatial values.
arg1 - is wrapped as val(Object).ST_DIFFERENCE function.
Get the difference of two spatial values.
arg2 - is wrapped as val(Object).ST_DIFFERENCE function.
Get the difference of two spatial values.
ST_DISJOINT function.
Check if a spatial value is disjoint from another.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_DISJOINT function.
Check if a spatial value is disjoint from another.
arg1 - is wrapped as val(Object).ST_DISJOINT function.
Check if a spatial value is disjoint from another.
arg2 - is wrapped as val(Object).ST_DISJOINT function.
Check if a spatial value is disjoint from another.
ST_DISTANCE function.
Get the distance between two spatial values.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_DISTANCE function.
Get the distance between two spatial values.
arg1 - is wrapped as val(Object).ST_DISTANCE function.
Get the distance between two spatial values.
arg2 - is wrapped as val(Object).ST_DISTANCE function.
Get the distance between two spatial values.
ST_ENDPOINT function.
Get the end point of a spatial value.
value - is wrapped as val(Object).ST_ENDPOINT function.
Get the end point of a spatial value.
ST_EQUALS function.
Check if a spatial value is equal to another.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_EQUALS function.
Check if a spatial value is equal to another.
arg1 - is wrapped as val(Object).ST_EQUALS function.
Check if a spatial value is equal to another.
arg2 - is wrapped as val(Object).ST_EQUALS function.
Check if a spatial value is equal to another.
ST_EXTERIORRING function.
Get the exterior ring of a spatial value.
value - is wrapped as val(Object).ST_EXTERIORRING function.
Get the exterior ring of a spatial value.
ST_GEOMETRYN function.
Get the N-th geometry from a collection of spatial values.
value - is wrapped as val(Object).position - is wrapped as val(Object).ST_GEOMETRYN function.
Get the N-th geometry from a collection of spatial values.
value - is wrapped as val(Object).ST_GEOMETRYN function.
Get the N-th geometry from a collection of spatial values.
position - is wrapped as val(Object).ST_GEOMETRYN function.
Get the N-th geometry from a collection of spatial values.
ST_GEOMETRYTYPE function.
Get the geometry type of a spatial value.
value - is wrapped as val(Object).ST_GEOMETRYTYPE function.
Get the geometry type of a spatial value.
ST_GEOMFROMTEXT function.
Create a geometry from a text representation.
text - is wrapped as val(Object).ST_GEOMFROMTEXT function.
Create a geometry from a text representation.
text - is wrapped as val(Object).ST_GEOMFROMTEXT function.
Create a geometry from a text representation.
ST_GEOMFROMTEXT function.
Create a geometry from a text representation.
ST_GEOMFROMTEXT function.
Create a geometry from a text representation.
text - is wrapped as val(Object).ST_GEOMFROMTEXT function.
Create a geometry from a text representation.
ST_GEOMFROMWKB function.
Create a geometry from a binary representation.
ST_GEOMFROMWKB function.
Create a geometry from a binary representation.
ST_GEOMFROMWKB function.
Create a geometry from a binary representation.
ST_GEOMFROMWKB function.
Create a geometry from a binary representation.
ST_GEOMFROMWKB function.
Create a geometry from a binary representation.
ST_GEOMFROMWKB function.
Create a geometry from a binary representation.
ST_INTERIORRINGN function.
Get the N-th interior ring of a spatial value.
value - is wrapped as val(Object).position - is wrapped as val(Object).ST_INTERIORRINGN function.
Get the N-th interior ring of a spatial value.
value - is wrapped as val(Object).ST_INTERIORRINGN function.
Get the N-th interior ring of a spatial value.
position - is wrapped as val(Object).ST_INTERIORRINGN function.
Get the N-th interior ring of a spatial value.
ST_INTERSECTION function.
Get the intersection of two spatial values.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_INTERSECTION function.
Get the intersection of two spatial values.
arg1 - is wrapped as val(Object).ST_INTERSECTION function.
Get the intersection of two spatial values.
arg2 - is wrapped as val(Object).ST_INTERSECTION function.
Get the intersection of two spatial values.
ST_INTERSECTS function.
Check whether two spatial values intersect.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_INTERSECTS function.
Check whether two spatial values intersect.
arg1 - is wrapped as val(Object).ST_INTERSECTS function.
Check whether two spatial values intersect.
arg2 - is wrapped as val(Object).ST_INTERSECTS function.
Check whether two spatial values intersect.
ST_ISCLOSED function.
Check whether a spatial value is closed.
value - is wrapped as val(Object).ST_ISCLOSED function.
Check whether a spatial value is closed.
ST_ISEMPTY function.
Check whether a spatial value is empty.
value - is wrapped as val(Object).ST_ISEMPTY function.
Check whether a spatial value is empty.
ST_LENGTH function.
Get the length of a spatial value.
value - is wrapped as val(Object).ST_LENGTH function.
Get the length of a spatial value.
ST_NUMGEOMETRIES function.
Get the number of geometries in a collection of spatial values.
value - is wrapped as val(Object).ST_NUMGEOMETRIES function.
Get the number of geometries in a collection of spatial values.
ST_NUMINTERIORRING function.
Get the number of interior rings of a spatial value.
value - is wrapped as val(Object).ST_NUMINTERIORRING function.
Get the number of interior rings of a spatial value.
ST_NUMPOINTS function.
Get the number of points in a spatial value.
value - is wrapped as val(Object).ST_NUMPOINTS function.
Get the number of points in a spatial value.
ST_OVERLAPS function.
Check whether two spatial values overlap.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_OVERLAPS function.
Check whether two spatial values overlap.
arg1 - is wrapped as val(Object).ST_OVERLAPS function.
Check whether two spatial values overlap.
arg2 - is wrapped as val(Object).ST_OVERLAPS function.
Check whether two spatial values overlap.
ST_POINTN function.
Get the Nth point of a spatial value.
value - The spatial value whose Nth point to findposition - The 1-based positionST_POINTN function.
Get the Nth point of a spatial value.
value - The spatial value whose Nth point to findposition - The 1-based positionST_POINTN function.
Get the Nth point of a spatial value.
value - The spatial value whose Nth point to findposition - The 1-based positionST_POINTN function.
Get the Nth point of a spatial value.
value - The spatial value whose Nth point to findposition - The 1-based positionST_SRID function.
Get the SRID of a spatial value.
value - is wrapped as val(Object).ST_SRID function.
Get the SRID of a spatial value.
ST_STARTPOINT function.
Get the start point of a spatial value.
value - is wrapped as val(Object).ST_STARTPOINT function.
Get the start point of a spatial value.
ST_TOUCHES function.
Check whether two spatial values touch.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_TOUCHES function.
Check whether two spatial values touch.
arg1 - is wrapped as val(Object).ST_TOUCHES function.
Check whether two spatial values touch.
arg2 - is wrapped as val(Object).ST_TOUCHES function.
Check whether two spatial values touch.
ST_UNION function.
Get the union of two spatial values.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_UNION function.
Get the union of two spatial values.
arg1 - is wrapped as val(Object).ST_UNION function.
Get the union of two spatial values.
arg2 - is wrapped as val(Object).ST_UNION function.
Get the union of two spatial values.
ST_WITHIN function.
Check if a spatial value is contained within another.
arg1 - is wrapped as val(Object).arg2 - is wrapped as val(Object).ST_WITHIN function.
Check if a spatial value is contained within another.
arg1 - is wrapped as val(Object).ST_WITHIN function.
Check if a spatial value is contained within another.
arg2 - is wrapped as val(Object).ST_WITHIN function.
Check if a spatial value is contained within another.
ST_X function.
Extract the X coordinate from the argument geometry.
value - is wrapped as val(Object).ST_X function.
Extract the X coordinate from the argument geometry.
ST_Y function.
Extract the Y coordinate from the argument geometry.
value - is wrapped as val(Object).ST_Y function.
Extract the Y coordinate from the argument geometry.
ST_Z function.
Extract the Z coordinate from the argument geometry.
value - is wrapped as val(Object).ST_Z function.
Extract the Z coordinate from the argument geometry.
replace(Field, String, String) to escape
data for use with Field.like(Field, char).
Essentially, this escapes % and _ characters
replace(Field, String, String) to escape
data for use with Field.like(Field, char).
Essentially, this escapes % and _ characters
REGEXP_REPLACE_ALL function.REGEXP_REPLACE_ALL function.REGEXP_REPLACE_FIRST function.REGEXP_REPLACE_FIRST function.concat(field, value) function.concat(value, field) function.
This creates fields[0] || fields[1] || … as an
expression, or concat(fields[0], fields[1], …),
depending on the dialect.
If any of the given fields is not a String field, they are cast
to Field<String> first using cast(Object, Class)
SQLDataType.DATE type.
Note, while there is a CURRENT_DATE function in
SQLDialect.ORACLE, that function returns a seconds-precision
SQLDataType.TIMESTAMP, which is undesired from a vendor
agnosticity perspective. This function thus produces an expression that
conforms to the SQL standard idea of a SQLDataType.DATE type.
This translates into any dialect
SQLDataType.TIME type.
This translates into any dialect
SQLDataType.TIMESTAMP type.
This translates into any dialect
SQLDataType.TIMESTAMP type with the specified fractional
seconds precision.SQLDataType.TIMESTAMP type with the specified fractional
seconds precision.currentTimestamp().currentTimestamp(Field).SQLDataType.DATE type.
Note, while there is a CURRENT_DATE function in
SQLDialect.ORACLE, that function returns a seconds-precision
SQLDataType.TIMESTAMP, which is undesired from a vendor
agnosticity perspective. This function thus produces an expression that
conforms to the SQL standard idea of a SQLDataType.DATE type.
This translates into any dialect
SQLDataType.TIME type.
This translates into any dialect
SQLDataType.TIMESTAMP type.
This translates into any dialect
SQLDataType.TIMESTAMP type with the specified fractional
seconds precision.SQLDataType.TIMESTAMP type with the specified fractional
seconds precision.This translates into any dialect
This translates into any dialect
This translates into any dialect
endDate - startDate in
number of days.endDate - startDate in
number of days.endDate - startDate in
number of days.endDate - startDate in
number of days.endDate - startDate in terms
of part.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
endDate - startDate in terms
of part.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in
number of days.endDate - startDate in
number of days.endDate - startDate in
number of days.endDate - startDate in
number of days.endDate - startDate in terms
of part.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
endDate - startDate in terms
of part.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate in terms
of part.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
This translates into any dialect
This translates into any dialect
This translates into any dialect
This is the same as calling extract(Field, DatePart)
with DatePart.EPOCH
This is the same as calling extract(Field, DatePart)
with DatePart.EPOCH
This is the same as calling extract(Field, DatePart)
with DatePart.EPOCH
This is the same as calling extract(Field, DatePart)
with DatePart.MILLENNIUM
This is the same as calling extract(Field, DatePart)
with DatePart.MILLENNIUM
This is the same as calling extract(Field, DatePart)
with DatePart.MILLENNIUM
This is the same as calling extract(Field, DatePart)
with DatePart.CENTURY
This is the same as calling extract(Field, DatePart)
with DatePart.CENTURY
This is the same as calling extract(Field, DatePart)
with DatePart.CENTURY
This is the same as calling extract(Field, DatePart)
with DatePart.DECADE
This is the same as calling extract(Field, DatePart)
with DatePart.DECADE
This is the same as calling extract(Field, DatePart)
with DatePart.DECADE
This is the same as calling extract(Field, DatePart)
with DatePart.QUARTER
This is the same as calling extract(Field, DatePart)
with DatePart.QUARTER
This is the same as calling extract(Field, DatePart)
with DatePart.QUARTER
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.YEAR
This is the same as calling extract(Temporal, DatePart)
with DatePart.YEAR
This is the same as calling extract(Field, DatePart)
with DatePart.YEAR
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.MONTH
This is the same as calling extract(Temporal, DatePart)
with DatePart.MONTH
This is the same as calling extract(Field, DatePart)
with DatePart.MONTH
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.WEEK
This is the same as calling extract(Temporal, DatePart)
with DatePart.WEEK
This is the same as calling extract(Field, DatePart)
with DatePart.WEEK
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.DAY
This is the same as calling extract(Temporal, DatePart)
with DatePart.DAY
This is the same as calling extract(Field, DatePart)
with DatePart.DAY
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.DAY_OF_WEEK
This is the same as calling extract(Temporal, DatePart)
with DatePart.DAY_OF_WEEK
This is the same as calling extract(Field, DatePart)
with DatePart.DAY_OF_WEEK
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.ISO_DAY_OF_WEEK
This is the same as calling extract(Temporal, DatePart)
with DatePart.ISO_DAY_OF_WEEK
This is the same as calling extract(Field, DatePart)
with DatePart.ISO_DAY_OF_WEEK
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.DAY_OF_YEAR
This is the same as calling extract(Temporal, DatePart)
with DatePart.DAY_OF_YEAR
This is the same as calling extract(Field, DatePart)
with DatePart.DAY_OF_YEAR
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.HOUR
This is the same as calling extract(Temporal, DatePart)
with DatePart.HOUR
This is the same as calling extract(Field, DatePart)
with DatePart.HOUR
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.MINUTE
This is the same as calling extract(Temporal, DatePart)
with DatePart.MINUTE
This is the same as calling extract(Field, DatePart)
with DatePart.MINUTE
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.SECOND
This is the same as calling extract(Temporal, DatePart)
with DatePart.SECOND
This is the same as calling extract(Field, DatePart)
with DatePart.SECOND
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.MILLISECOND
This is the same as calling extract(Temporal, DatePart)
with DatePart.MILLISECOND
This is the same as calling extract(Field, DatePart)
with DatePart.MILLISECOND
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.MICROSECOND
This is the same as calling extract(Temporal, DatePart)
with DatePart.MICROSECOND
This is the same as calling extract(Field, DatePart)
with DatePart.MICROSECOND
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.TIMEZONE
This is the same as calling extract(Temporal, DatePart)
with DatePart.TIMEZONE
This is the same as calling extract(Field, DatePart)
with DatePart.TIMEZONE
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.TIMEZONE_HOUR
This is the same as calling extract(Temporal, DatePart)
with DatePart.TIMEZONE_HOUR
This is the same as calling extract(Field, DatePart)
with DatePart.TIMEZONE_HOUR
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.TIMEZONE_MINUTE
This is the same as calling extract(Temporal, DatePart)
with DatePart.TIMEZONE_MINUTE
This is the same as calling extract(Field, DatePart)
with DatePart.TIMEZONE_MINUTE
DATE.DATE.DATE.TIME.TIME.TIME.TIMESTAMP.TIMESTAMP.TIMESTAMP.DATE.DATE.DATE.TIME.TIME.TIME.TIMESTAMP.TIMESTAMP.TIMESTAMP.TIME WITH TIME ZONE.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE) or not (e.g.
SQLDialect.POSTGRES), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant (in UTC) as the input.
TIME WITH TIME ZONE.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE) or not (e.g.
SQLDialect.POSTGRES), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant (in UTC) as the input.
TIME WITH TIME ZONE.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE) or not (e.g.
SQLDialect.POSTGRES), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant (in UTC) as the input.
TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE) or not (e.g.
SQLDialect.POSTGRES), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant (in UTC) as the input.
TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE) or not (e.g.
SQLDialect.POSTGRES), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant (in UTC) as the input.
TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE) or not (e.g.
SQLDialect.POSTGRES), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant (in UTC) as the input.
TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE) or not (e.g.
SQLDialect.POSTGRES), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant (in UTC) as the input.
TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE) or not (e.g.
SQLDialect.POSTGRES), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant (in UTC) as the input.
TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE) or not (e.g.
SQLDialect.POSTGRES), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant (in UTC) as the input.
DATE.value - The formatted DATE value.format - The vendor-specific formatting string.DATE.value - The formatted DATE value.format - The vendor-specific formatting string.DATE.value - The formatted DATE value.format - The vendor-specific formatting string.DATE.value - The formatted DATE value.format - The vendor-specific formatting string.TIMESTAMP.value - The formatted TIMESTAMP value.format - The vendor-specific formatting string.TIMESTAMP.value - The formatted TIMESTAMP value.format - The vendor-specific formatting string.TIMESTAMP.value - The formatted TIMESTAMP value.format - The vendor-specific formatting string.TIMESTAMP.value - The formatted TIMESTAMP value.format - The vendor-specific formatting string.
Please check the SQL Server documentation for a very nice explanation of
CUBE, ROLLUP, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fields - The fields that are part of the GROUPING SETS
functionGROUP BY clause
Please check the SQL Server documentation for a very nice explanation of
CUBE, ROLLUP, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fields - The fields that are part of the ROLLUP
functionGROUP BY clause
Please check the SQL Server documentation for a very nice explanation of
CUBE, ROLLUP, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fields - The fields that are part of the CUBE
functionGROUP BY clause
Please check the SQL Server documentation for a very nice explanation of
CUBE, ROLLUP, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fields - The fields that are part of the GROUPING SETS
functionGROUP BY clause
Please check the SQL Server documentation for a very nice explanation of
CUBE, ROLLUP, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fieldSets - The fields that are part of the GROUPING SETS
functionGROUP BY clause
Please check the SQL Server documentation for a very nice explanation of
CUBE, ROLLUP, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fieldSets - The fields that are part of the GROUPING SETS
functionGROUP BY clauseGROUP_ID() aggregation function to be used along
with CUBE, ROLLUP, and
GROUPING SETS groupings.GROUPING aggregation fieldCUBE, ROLLUP, and
GROUPING SETS groupings.fields - The function argumentsGROUPING_ID aggregation fieldCUBE, ROLLUP, and GROUPING SETS
groupings.field - The function argumentGROUPING aggregation field
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere. Its current simulation implementation has
O(2^n) complexity and should be avoided for
n > 5! Better implementation suggestions are very
welcome.
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere. Its current simulation implementation has
O(2^n) complexity and should be avoided for
n > 5! Better implementation suggestions are very
welcome.
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere. Its current simulation implementation has
O(2^n) complexity and should be avoided for
n > 5! Better implementation suggestions are very
welcome.
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere. Its current simulation implementation has
O(2^n) complexity and should be avoided for
n > 5! Better implementation suggestions are very
welcome.
jsonObject(JSONEntry...).
This is the same as calling jsonEntry(String, Field).
jsonObject(JSONEntry...).
This is the same as calling jsonEntry(Field, Field).
jsonObject(JSONEntry...).
This is the same as calling jsonEntry(String, Field) with
Field.getName() as a key.
jsonObject(JSONEntry...).jsonObject(JSONEntry...).jsonObject(JSONEntry...).jsonObject(JSONEntry...).jsonObject(JSONEntry...).jsonObject(JSONEntry...).Field
arguments in this method is inconsistent with that of other
overloads, such as jsonbObject(Field, Field), which
can lead to subtle bugs. Please refrain from using this
overload as it will be removed in the future. Use
jsonObject(JSONEntry...) instead.JSON_OBJECT function.Field
arguments in this method is inconsistent with that of other
overloads, such as jsonbObject(Field, Field), which
can lead to subtle bugs. Please refrain from using this
overload as it will be removed in the future. Use
jsonObject(JSONEntry...) instead.JSONB_OBJECT function.
This is the same as calling jsonEntry(String, Field) with
Field.getName() as a key.
This is the same as calling jsonEntry(String, Field) with
Field.getName() as a key.
array(select) function.
Example:
{1, 2, 3} = array(select 1 union select 2 union select 3)
MULTISET operator to nest subqueries.
The standard SQL MULTISET operator is emulated using
elaborate mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.NATIVE: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
An important limitation is that correlating MULTISET
subqueries currently only fully works on dialects that support
correlating derived tables. This excludes:
On the above dialects, a simplified emulation is implemented, which does
not support the following inside of MULTISET:
SELECT DISTINCTGROUP BYHAVINGWINDOWQUALIFYOFFSETLIMITUNION and other set operations
See also https://github.com/jOOQ/jOOQ/issues/12045.
The various multisetAgg(Field...) overloads are not affected
from this limitation.
If this is not supported by a given database (i.e. non
SQLDialect.POSTGRES, then the primary key is used with
count(Field), instead.
If this is not supported by a given database (i.e. non
SQLDialect.POSTGRES, then the primary key is used with
count(Field), instead.
Some dialects support several expressions in the
COUNT(DISTINCT expr1, expr2) aggregate function.
SQLDialect.POSTGRES supports this as
COUNT(DISTINCT(expr1, expr2)).
array_agg() aggregate function.array_agg() aggregate function.MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.NATIVE: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.NATIVE: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAgg(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAgg(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.XML: A MULTISET of ROW types works
just like a xmlagg(Field) of
xmlelement(Name, Field...), or an application of
SelectForStep.forXML(). jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String). Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat.NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
MULTISET_AGG(DISTINCT) aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON: A MULTISET of ROW types works
just like a jsonArrayAggDistinct(Field) of
jsonObject(Field...), or an application of
SelectForStep.forJSON(). jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String). Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat.NestedCollectionEmulation.JSONB: Just like JSON,
but we're using jsonbArrayAggDistinct(Field) and
jsonbObject(Field...), or SelectForStep.forJSONB().NestedCollectionEmulation.DEFAULT: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
Note that unlike MULTISET_AGG, this depends on whether the
underlying emulation supports the DISTINCT clause.
The emulation to be chosen is governed by
Settings.getEmulateMultiset().
collect() aggregate function.
In Oracle, a standalone collect() expression generates an
anonymous collection type, which can be used by clients only if cast
explicitly to a user-defined collection type. The latter can be supplied
here for convenience as the second argument.
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
collect(Field, DataType).
collect() aggregate function.
In Oracle, a standalone collect() expression generates an
anonymous collection type, which can be used by clients only if cast
explicitly to a user-defined collection type. The latter can be supplied
here for convenience as the second argument.
collect() aggregate function.
In Oracle, a standalone collect() expression generates an
anonymous collection type, which can be used by clients only if cast
explicitly to a user-defined collection type. The latter can be supplied
here for convenience as the second argument.
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
collectDistinct(Field, DataType).
collect() aggregate function.
In Oracle, a standalone collect() expression generates an
anonymous collection type, which can be used by clients only if cast
explicitly to a user-defined collection type. The latter can be supplied
here for convenience as the second argument.
mode(field) aggregate function.This is natively supported by
SQLDialect.AURORA_MYSQLSQLDialect.H2SQLDialect.HSQLDBSQLDialect.MEMSQL (but without ORDER BY)SQLDialect.MYSQLSQLDialect.SQLITE (but without ORDER BY)It is emulated by the following dialects:
SQLDialect.DB2: Using XMLAGG()SQLDialect.ORACLE: Using LISTAGG()SQLDialect.POSTGRES: Using STRING_AGG()SQLDialect.SYBASE: Using LIST()groupConcat(Field) and
GroupConcatSeparatorStep.separator(String) instead.This is natively supported by
SQLDialect.AURORA_MYSQLSQLDialect.H2SQLDialect.HSQLDBSQLDialect.MEMSQLSQLDialect.MYSQLSQLDialect.SQLITEIt is emulated by the following dialects:
SQLDialect.DB2: Using XMLAGG()SQLDialect.ORACLE: Using LISTAGG()SQLDialect.POSTGRES: Using STRING_AGG()SQLDialect.SYBASE: Using LIST()This is natively supported by
It is emulated by the following dialects:
SQLDialect.SYBASE: Using LIST()SQLDialect.POSTGRES: Using STRING_AGG()mode() within group (oder by [order clause]) ordered
aggregate function.rank(expr) within group (order by [order clause])
ordered-set aggregate function.rank(expr) within group (order by [order clause])
ordered-set aggregate function.dense_rank(expr) within group (order by [order clause])
ordered-set aggregate function.dense_rank(expr) within group (order by [order clause])
ordered-set aggregate function.percent_rank(expr) within group (order by [order clause])
ordered-set aggregate function.percent_rank(expr) within group (order by [order clause])
ordered-set aggregate function.cume_dist(expr) within group (order by [order clause])
ordered-set aggregate function.cume_dist(expr) within group (order by [order clause])
ordered-set aggregate function.percentile_cont([number]) within group (order by [column])
function.
While most dialects support this as an aggregate function,
SQLDialect.BIGQUERY, SQLDialect.SQLSERVER, and
SQLDialect.REDSHIFT support only its window function variant.
percentile_cont([number]) within group (order by [column])
function.
While most dialects support this as an aggregate function,
SQLDialect.BIGQUERY, SQLDialect.SQLSERVER, and
SQLDialect.REDSHIFT support only its window function variant.
percentile_disc([number]) within group (order by [column])
function.
While most dialects support this as an aggregate function,
SQLDialect.BIGQUERY, SQLDialect.SQLSERVER, and
SQLDialect.REDSHIFT support only its window function variant.
percentile_disc([number]) within group (order by [column])
function.
While most dialects support this as an aggregate function,
SQLDialect.BIGQUERY, SQLDialect.SQLSERVER, and
SQLDialect.REDSHIFT support only its window function variant.
WindowSpecification with a PARTITION BY clause.WindowSpecification with a PARTITION BY clause.WindowSpecification with an ORDER BY clause.WindowSpecification with an ORDER BY clause.WindowSpecification with an ORDER BY clause.WindowSpecification with a ROWS clause.WindowSpecification with a ROWS clause.WindowSpecification with a ROWS clause.WindowSpecification with a ROWS clause.WindowSpecification with a ROWS clause.WindowSpecification with a ROWS clause.WindowSpecification with a ROWS clause.WindowSpecification with a ROWS clause.WindowSpecification with a ROWS clause.WindowSpecification with a ROWS clause.WindowSpecification with a RANGE clause.WindowSpecification with a RANGE clause.WindowSpecification with a RANGE clause.WindowSpecification with a RANGE clause.WindowSpecification with a RANGE clause.WindowSpecification with a RANGE clause.WindowSpecification with a RANGE clause.WindowSpecification with a RANGE clause.WindowSpecification with a RANGE clause.WindowSpecification with a RANGE clause.WindowSpecification with a GROUPS clause.WindowSpecification with a GROUPS clause.WindowSpecification with a GROUPS clause.WindowSpecification with a GROUPS clause.WindowSpecification with a GROUPS clause.WindowSpecification with a GROUPS clause.WindowSpecification with a GROUPS clause.WindowSpecification with a GROUPS clause.WindowSpecification with a GROUPS clause.WindowSpecification with a GROUPS clause.row_number() over ([analytic clause]) function.
Newer versions of SQLDialect.DERBY and SQLDialect.H2 also
support the ROW_NUMBER() OVER() window function without any
window clause. See the respective docs for details.
SQLDialect.HSQLDB can emulate this function using
ROWNUM()
rank() over ([analytic clause]) function.dense_rank() over ([analytic clause]) function.percent_rank() over ([analytic clause]) function.cume_dist() over ([analytic clause]) function.ntile([number]) over ([analytic clause]) function.ntile([number]) over ([analytic clause]) function.ratio_to_report([expression]) over ([analytic clause]) function.ratio_to_report([expression]) over ([analytic clause]) function.first_value(field) over ([analytic clause]) function.last_value(field) over ([analytic clause]) function.nth_value(field) over ([analytic clause]) function.nth_value(field) over ([analytic clause]) function.lead(field) over ([analytic clause]) function.lead(field, offset) over ([analytic clause]) function.lead(field, offset) over ([analytic clause]) function.lead(field, offset, defaultValue) over ([analytic clause])
function.lead(field, offset, defaultValue) over ([analytic clause])
function.lead(field, offset, defaultValue) over ([analytic clause])
function.lead(field, offset, defaultValue) over ([analytic clause])
function.lag(field) over ([analytic clause]) function.lag(field, offset) over ([analytic clause]) function.lag(field, offset) over ([analytic clause]) function.lag(field, offset, defaultValue) over ([analytic clause])
function.lag(field, offset, defaultValue) over ([analytic clause])
function.lag(field, offset, defaultValue) over ([analytic clause])
function.lag(field, offset, defaultValue) over ([analytic clause])
function.Object /
SQLDataType.OTHER) and no initial value.
Try to avoid this method when using any of these databases, as these
databases may have trouble inferring the type of the bind value. Use
typed named parameters instead, using param(Class) or
param(DataType)
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
param(DataType).
Object /
SQLDataType.OTHER) and no initial value.
Try to avoid this method when using any of these databases, as these
databases may have trouble inferring the type of the bind value. Use
typed named parameters instead, using param(String, Class) or
param(String, DataType)
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
param(String, DataType).
name - The parameter nametype - The type that is used for the parameter (a type that is
supported by SQLDataType)Named parameters are useful for several use-cases:
JdbcTemplate, which
supports named parameters. Use
DSLContext.renderNamedParams(QueryPart) to render
parameter names in SQLAttachableQueryPart.getParam(String) and AttachableQueryPart.getParams().val(Object) to be used in Scala and Groovy, where
val is a reserved keyword.
NOTE [#15286]: It is strongly recommended to pass only
instances of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
value(Object, DataType).
val(byte) to be used in Scala and Groovy, where
val is a reserved keyword.val(Byte) to be used in Scala and Groovy, where
val is a reserved keyword.val(UByte) to be used in Scala and Groovy, where
val is a reserved keyword.val(short) to be used in Scala and Groovy, where
val is a reserved keyword.val(Short) to be used in Scala and Groovy, where
val is a reserved keyword.val(UShort) to be used in Scala and Groovy, where
val is a reserved keyword.val(int) to be used in Scala and Groovy, where
val is a reserved keyword.val(Integer) to be used in Scala and Groovy, where
val is a reserved keyword.val(UInteger) to be used in Scala and Groovy, where
val is a reserved keyword.val(long) to be used in Scala and Groovy, where
val is a reserved keyword.val(Long) to be used in Scala and Groovy, where
val is a reserved keyword.val(ULong) to be used in Scala and Groovy, where
val is a reserved keyword.val(float) to be used in Scala and Groovy, where
val is a reserved keyword.val(Float) to be used in Scala and Groovy, where
val is a reserved keyword.val(double) to be used in Scala and Groovy, where
val is a reserved keyword.val(Double) to be used in Scala and Groovy, where
val is a reserved keyword.val(boolean) to be used in Scala and Groovy, where
val is a reserved keyword.val(Boolean) to be used in Scala and Groovy, where
val is a reserved keyword.val(BigDecimal) to be used in Scala and Groovy, where
val is a reserved keyword.val(BigInteger) to be used in Scala and Groovy, where
val is a reserved keyword.val(byte[]) to be used in Scala and Groovy, where
val is a reserved keyword.val(String) to be used in Scala and Groovy, where
val is a reserved keyword.val(Date) to be used in Scala and Groovy, where
val is a reserved keyword.val(Time) to be used in Scala and Groovy, where
val is a reserved keyword.val(Timestamp) to be used in Scala and Groovy, where
val is a reserved keyword.val(LocalDate) to be used in Scala and Groovy, where
val is a reserved keyword.val(LocalTime) to be used in Scala and Groovy, where
val is a reserved keyword.val(LocalDateTime) to be used in Scala and Groovy, where
val is a reserved keyword.val(OffsetTime) to be used in Scala and Groovy, where
val is a reserved keyword.val(OffsetDateTime) to be used in Scala and Groovy, where
val is a reserved keyword.val(Instant) to be used in Scala and Groovy, where
val is a reserved keyword.val(UUID) to be used in Scala and Groovy, where
val is a reserved keyword.val(JSON) to be used in Scala and Groovy, where
val is a reserved keyword.val(JSONB) to be used in Scala and Groovy, where
val is a reserved keyword.val(XML) to be used in Scala and Groovy, where
val is a reserved keyword.val(Geography) to be used in Scala and Groovy, where
val is a reserved keyword.val(Geometry) to be used in Scala and Groovy, where
val is a reserved keyword.val(Object, Class) to be used in Scala and Groovy,
where val is a reserved keyword.
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
value(Object, DataType).
value - The bind valuetype - The type that is used for the bind value (a type that is
supported by SQLDataType)val(Object, Field) to be used in Scala and Groovy, where
val is a reserved keyword.val(Object, DataType) to be used in Scala and Groovy, where
val is a reserved keyword.Field.Condition.QueryPart.Statement.
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
NOTE [#15286]: It is strongly recommended to pass only
instances of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
inline(Object, DataType).
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String), you can expect value to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
This is a convenience method for inline(Object), returning
Field<String>, rather than
Field<Character>
This is a convenience method for inline(Object), returning
Field<String>, rather than
Field<Character>
This is a convenience method for inline(Object), returning
Field<String>, rather than
Field<CharSequence>
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String, Class), you can expect
value to be properly escaped for SQL syntax correctness and
SQL injection prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
inline(Object, DataType).
value - The inline valuetype - The data type to enforce upon the value (a type that is
supported by SQLDataType)
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String, DataType), you can expect
value to be properly escaped for SQL syntax correctness and
SQL injection prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType() property of the rendering factory.
Unlike with field(String, DataType), you can expect
value to be properly escaped for SQL syntax correctness and
SQL injection prevention. For example:
inline("abc'def") renders 'abc''def'field("abc'def") renders abc'def
jOOQ tries to derive the RDBMS DataType from the provided Java
type <T>. This may not always be accurate, which can
lead to problems in some strongly typed RDMBS, especially when value is
null. These databases are namely:
If you need more type-safety, please use val(Object, DataType)
instead, and provide the precise RDMBS-specific data type, that is
needed.
NOTE [#15286]: It is strongly recommended to pass only
instances of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
val(Object, DataType).
T - The generic value typevalue - The constant value
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
val(Object, DataType).
T - The generic value typevalue - The constant valuetype - The data type to enforce upon the value (a type that is
supported by SQLDataType)T - The generic value typevalue - The constant valuefield - The field whose data type to enforce upon the value
This will try to bind value as type in a
PreparedStatement. If value and
type are not compatible, jOOQ will first try to convert and
then to cast value to type.
T - The generic value typevalue - The constant valuetype - The data type to enforce upon the valueRecordType of an arbitrary degree.RecordType of an arbitrary degree.RecordType of degree 1.RecordType of degree 2.RecordType of degree 3.RecordType of degree 4.RecordType of degree 5.RecordType of degree 6.RecordType of degree 7.RecordType of degree 8.RecordType of degree 9.RecordType of degree 10.RecordType of degree 11.RecordType of degree 12.RecordType of degree 13.RecordType of degree 14.RecordType of degree 15.RecordType of degree 16.RecordType of degree 17.RecordType of degree 18.RecordType of degree 19.RecordType of degree 20.RecordType of degree 21.RecordType of degree 22.1.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
2.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
3.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
4.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
5.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
6.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
7.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
8.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
9.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
10.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
11.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
12.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
13.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
14.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
15.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
16.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
17.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
18.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
19.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
20.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
21.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
22.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
N > 22.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
1.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
2.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
3.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
4.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
5.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
6.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
7.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
8.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
9.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
10.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
11.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
12.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
13.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
14.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
15.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
16.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
17.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
18.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
19.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
20.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
21.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
22.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
N > 22.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
N > 22.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
VALUES() expression of arbitrary degree.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2),
(val2_1, val2_2),
(val3_1, val3_2)
AS "v"("c1" , "c2" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 1.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1),
(val2_1),
(val3_1)
AS "v"("c1" )
-- Using UNION ALL
SELECT val1_1 AS "c1") UNION ALL
SELECT val1_1 AS "c1") UNION ALL
SELECT val1_1 AS "c1")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 2.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2),
(val2_1, val2_2),
(val3_1, val3_2)
AS "v"("c1" , "c2" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 3.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3),
(val2_1, val2_2, val2_3),
(val3_1, val3_2, val3_3)
AS "v"("c1" , "c2" , "c3" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 4.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4),
(val2_1, val2_2, val2_3, val2_4),
(val3_1, val3_2, val3_3, val3_4)
AS "v"("c1" , "c2" , "c3" , "c4" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 5.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5),
(val2_1, val2_2, val2_3, val2_4, val2_5),
(val3_1, val3_2, val3_3, val3_4, val3_5)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 6.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 7.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 8.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 9.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 10.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 11.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 12.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 13.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 14.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 15.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 16.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 17.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 18.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" , "c18" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 19.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" , "c18" , "c19" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 20.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19, val1_20),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19, val2_20),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19, val3_20)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" , "c18" , "c19" , "c20" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 21.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19, val1_20, val1_21),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19, val2_20, val2_21),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19, val3_20, val3_21)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" , "c18" , "c19" , "c20" , "c21" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21")
Use Table.as(String, String...) to rename the resulting table and
its columns.
VALUES() expression of degree 22.
The VALUES() constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES() constructor, it
can be emulated using SELECT … UNION ALL …. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19, val1_20, val1_21, val1_22),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19, val2_20, val2_21, val2_22),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19, val3_20, val3_21, val3_22)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" , "c18" , "c19" , "c20" , "c21" , "c22" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21", val1_22 AS "c22") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21", val1_22 AS "c22") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21", val1_22 AS "c22")
Use Table.as(String, String...) to rename the resulting table and
its columns.
*) to be used in SELECT clauses.
When using an asterisk, jOOQ will let the database server define the order of columns, as well as which columns are included in the result set. If using jOOQ with generated code, this may conflict with the column set and its ordering as defined at code generation time, meaning columns may be in a different order, there may be fewer or more columns than expected. It is usually better to list columns explicitly.
0 literal.
This is useful for mathematical functions or for
EXISTS (SELECT 0 …) or PARTITION BY 0 clauses
and similar constructs. The 0 literal will not generate a
bind variable.
0 literal as a Field1 literal.
This is useful for mathematical functions or for
EXISTS (SELECT 1 …) or PARTITION BY 1 clauses
and similar constructs. The 1 literal will not generate a
bind variable.
1 literal as a Field2 literal.
This is useful for mathematical functions. The 1 literal
will not generate a bind variable.
2 literal as a FieldDSLContext's underlying
SQLDialect and a given Java type.
NOTE [#15286]: It is strongly recommended to pass only
Class references of types supported by jOOQ internally, i.e.
types from SQLDataType. If you're using any custom data types by
means of a Converter or Binding, it's better to pass that
converted DataType reference explicitly to
param(DataType).
T - The generic typetype - The Java type. This must be a type supported by
SQLDataType.DSL's underlying default data type.