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 ConditionarrayAllMatch(Field<T[]> array,
Function1<? super Field<T>,? extends Condition> predicate) ARRAY_ALL_MATCH function.static <T> @NotNull ConditionarrayAllMatch(Field<T[]> array,
Lambda1<Field<T>,Condition> predicate) ARRAY_ALL_MATCH function.static <T> @NotNull ConditionarrayAllMatch(T[] array,
Function1<? super Field<T>,? extends Condition> predicate) ARRAY_ALL_MATCH function.static <T> @NotNull ConditionarrayAllMatch(T[] array,
Lambda1<Field<T>,Condition> predicate) ARRAY_ALL_MATCH function.static <T> @NotNull ConditionarrayAnyMatch(Field<T[]> array,
Function1<? super Field<T>,? extends Condition> predicate) ARRAY_ANY_MATCH function.static <T> @NotNull ConditionarrayAnyMatch(Field<T[]> array,
Lambda1<Field<T>,Condition> predicate) ARRAY_ANY_MATCH function.static <T> @NotNull ConditionarrayAnyMatch(T[] array,
Function1<? super Field<T>,? extends Condition> predicate) ARRAY_ANY_MATCH function.static <T> @NotNull ConditionarrayAnyMatch(T[] array,
Lambda1<Field<T>,Condition> predicate) ARRAY_ANY_MATCH function.static <T> @NotNull Field<T[]> arrayAppend(Field<T[]> array,
Field<T> append) ARRAY_APPEND function.static <T> @NotNull Field<T[]> arrayAppend(Field<T[]> array,
T append) ARRAY_APPEND function.static <T> @NotNull Field<T[]> arrayAppend(T[] array,
Field<T> append) ARRAY_APPEND function.static <T> @NotNull Field<T[]> arrayAppend(T[] array,
T append) ARRAY_APPEND function.static <T> @NotNull Field<T[]> arrayConcat(Field<T[]> array1,
Field<T[]> array2) ARRAY_CONCAT function.static <T> @NotNull Field<T[]> arrayConcat(Field<T[]> array1,
T[] array2) ARRAY_CONCAT function.static <T> @NotNull Field<T[]> arrayConcat(T[] array1,
Field<T[]> array2) ARRAY_CONCAT function.static <T> @NotNull Field<T[]> arrayConcat(T[] array1,
T[] array2) ARRAY_CONCAT function.static <T> @NotNull Field<T[]> arrayFilter(Field<T[]> array,
Function1<? super Field<T>,? extends Condition> predicate) ARRAY_FILTER function.static <T> @NotNull Field<T[]> arrayFilter(Field<T[]> array,
Lambda1<Field<T>,Condition> predicate) ARRAY_FILTER function.static <T> @NotNull Field<T[]> arrayFilter(T[] array,
Function1<? super Field<T>,? extends Condition> predicate) ARRAY_FILTER function.static <T> @NotNull Field<T[]> arrayFilter(T[] array,
Lambda1<Field<T>,Condition> predicate) ARRAY_FILTER function.static <T> @NotNull Field<T> ARRAY_GET function.static <T> @NotNull Field<T> ARRAY_GET function.static <T,
U> @NotNull Field<U[]> ARRAY_MAP function.static <T,
U> @NotNull Field<U[]> ARRAY_MAP function.static <T,
U> @NotNull Field<U[]> ARRAY_MAP function.static <T,
U> @NotNull Field<U[]> ARRAY_MAP function.static <T> @NotNull ConditionarrayNoneMatch(Field<T[]> array,
Function1<? super Field<T>,? extends Condition> predicate) ARRAY_NONE_MATCH function.static <T> @NotNull ConditionarrayNoneMatch(Field<T[]> array,
Lambda1<Field<T>,Condition> predicate) ARRAY_NONE_MATCH function.static <T> @NotNull ConditionarrayNoneMatch(T[] array,
Function1<? super Field<T>,? extends Condition> predicate) ARRAY_NONE_MATCH function.static <T> @NotNull ConditionarrayNoneMatch(T[] array,
Lambda1<Field<T>,Condition> predicate) ARRAY_NONE_MATCH function.static <T> @NotNull ConditionarrayOverlap(Field<T[]> array1,
Field<T[]> array2) ARRAY_OVERLAP function.static <T> @NotNull ConditionarrayOverlap(Field<T[]> array1,
T[] array2) ARRAY_OVERLAP function.static <T> @NotNull ConditionarrayOverlap(T[] array1,
Field<T[]> array2) ARRAY_OVERLAP function.static <T> @NotNull ConditionarrayOverlap(T[] array1,
T[] array2) ARRAY_OVERLAP function.static <T> @NotNull Field<T[]> arrayPrepend(Field<T> prepend,
Field<T[]> array) ARRAY_PREPEND function.static <T> @NotNull Field<T[]> arrayPrepend(Field<T> prepend,
T[] array) ARRAY_PREPEND function.static <T> @NotNull Field<T[]> arrayPrepend(T prepend,
Field<T[]> array) ARRAY_PREPEND function.static <T> @NotNull Field<T[]> arrayPrepend(T prepend,
T[] array) ARRAY_PREPEND function.static <T> @NotNull Field<T[]> arrayRemove(Field<T[]> array,
Field<T> remove) ARRAY_REMOVE function.static <T> @NotNull Field<T[]> arrayRemove(Field<T[]> array,
T remove) ARRAY_REMOVE function.static <T> @NotNull Field<T[]> arrayRemove(T[] array,
Field<T> remove) ARRAY_REMOVE function.static <T> @NotNull Field<T[]> arrayRemove(T[] array,
T remove) ARRAY_REMOVE function.static <T> @NotNull Field<T[]> arrayReplace(Field<T[]> array,
Field<T> search,
Field<T> replace) ARRAY_REPLACE function.static <T> @NotNull Field<T[]> arrayReplace(T[] array,
T search,
T replace) ARRAY_REPLACE function.arrayToString(Object[] array,
String delimiter) ARRAY_TO_STRING function.arrayToString(Object[] array,
String delimiter,
String nullString) ARRAY_TO_STRING function.arrayToString(Field<? extends Object[]> array,
Field<String> delimiter) ARRAY_TO_STRING function.ARRAY_TO_STRING 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 BlockbinaryBitLength(byte[] bytes) BINARY_BIT_LENGTH function.binaryBitLength(Field<byte[]> bytes) BINARY_BIT_LENGTH function.static @NotNull Field<byte[]> binaryConcat(byte[] bytes1,
byte[] bytes2) BINARY_CONCAT function.static @NotNull Field<byte[]> binaryConcat(byte[] bytes1,
Field<byte[]> bytes2) BINARY_CONCAT function.static @NotNull Field<byte[]> binaryConcat(Field<byte[]> bytes1,
byte[] bytes2) BINARY_CONCAT function.static @NotNull Field<byte[]> binaryConcat(Field<byte[]> bytes1,
Field<byte[]> bytes2) BINARY_CONCAT function.binaryLength(byte[] bytes) BINARY_LENGTH function.binaryLength(Field<byte[]> bytes) BINARY_LENGTH function.static @NotNull OrderedAggregateFunction<byte[]> binaryListAgg(Field<?> field) static @NotNull OrderedAggregateFunction<byte[]> binaryListAgg(Field<?> field,
byte[] separator) static @NotNull OrderedAggregateFunction<byte[]> binaryListAgg(Field<?> field,
Field<byte[]> separator) static @NotNull OrderedAggregateFunction<byte[]> binaryListAggDistinct(Field<?> field) static @NotNull OrderedAggregateFunction<byte[]> binaryListAggDistinct(Field<?> field,
byte[] separator) static @NotNull OrderedAggregateFunction<byte[]> binaryListAggDistinct(Field<?> field,
Field<byte[]> separator) static @NotNull Field<byte[]> binaryLtrim(byte[] bytes,
byte[] characters) BINARY_LTRIM function.static @NotNull Field<byte[]> binaryLtrim(byte[] bytes,
Field<byte[]> characters) BINARY_LTRIM function.static @NotNull Field<byte[]> binaryLtrim(Field<byte[]> bytes,
byte[] characters) BINARY_LTRIM function.static @NotNull Field<byte[]> binaryLtrim(Field<byte[]> bytes,
Field<byte[]> characters) BINARY_LTRIM function.static @NotNull Field<byte[]> binaryMd5(byte[] bytes) BINARY_MD5 function.static @NotNull Field<byte[]> BINARY_MD5 function.binaryOctetLength(byte[] bytes) BINARY_OCTET_LENGTH function.binaryOctetLength(Field<byte[]> bytes) BINARY_OCTET_LENGTH function.static @NotNull Field<byte[]> binaryOverlay(Field<byte[]> in,
byte[] placing,
Number startIndex) BINARY_OVERLAY function.static @NotNull Field<byte[]> binaryOverlay(Field<byte[]> in,
byte[] placing,
Number startIndex,
Number length) BINARY_OVERLAY function.static @NotNull Field<byte[]> binaryOverlay(Field<byte[]> in,
Field<byte[]> placing,
Field<? extends Number> startIndex) BINARY_OVERLAY function.static @NotNull Field<byte[]> binaryOverlay(Field<byte[]> in,
Field<byte[]> placing,
Field<? extends Number> startIndex,
Field<? extends Number> length) BINARY_OVERLAY function.binaryPosition(byte[] in,
byte[] search) BINARY_POSITION function.binaryPosition(byte[] in,
byte[] search,
int startIndex) BINARY_POSITION function.binaryPosition(byte[] in,
byte[] search,
Field<? extends Number> startIndex) BINARY_POSITION function.binaryPosition(byte[] in,
Field<byte[]> search) BINARY_POSITION function.binaryPosition(byte[] in,
Field<byte[]> search,
int startIndex) BINARY_POSITION function.binaryPosition(byte[] in,
Field<byte[]> search,
Field<? extends Number> startIndex) BINARY_POSITION function.binaryPosition(Field<byte[]> in,
byte[] search) BINARY_POSITION function.binaryPosition(Field<byte[]> in,
byte[] search,
int startIndex) BINARY_POSITION function.binaryPosition(Field<byte[]> in,
byte[] search,
Field<? extends Number> startIndex) BINARY_POSITION function.binaryPosition(Field<byte[]> in,
Field<byte[]> search) BINARY_POSITION function.binaryPosition(Field<byte[]> in,
Field<byte[]> search,
int startIndex) BINARY_POSITION function.binaryPosition(Field<byte[]> in,
Field<byte[]> search,
Field<? extends Number> startIndex) BINARY_POSITION function.static @NotNull Field<byte[]> binaryRtrim(byte[] bytes,
byte[] characters) BINARY_RTRIM function.static @NotNull Field<byte[]> binaryRtrim(byte[] bytes,
Field<byte[]> characters) BINARY_RTRIM function.static @NotNull Field<byte[]> binaryRtrim(Field<byte[]> bytes,
byte[] characters) BINARY_RTRIM function.static @NotNull Field<byte[]> binaryRtrim(Field<byte[]> bytes,
Field<byte[]> characters) BINARY_RTRIM function.static @NotNull Field<byte[]> binarySubstring(Field<byte[]> string,
int startingPosition) BINARY_SUBSTRING function.static @NotNull Field<byte[]> binarySubstring(Field<byte[]> string,
int startingPosition,
int length) BINARY_SUBSTRING function.static @NotNull Field<byte[]> binarySubstring(Field<byte[]> string,
int startingPosition,
Field<? extends Number> length) BINARY_SUBSTRING function.static @NotNull Field<byte[]> binarySubstring(Field<byte[]> string,
Field<? extends Number> startingPosition) BINARY_SUBSTRING function.static @NotNull Field<byte[]> binarySubstring(Field<byte[]> string,
Field<? extends Number> startingPosition,
int length) BINARY_SUBSTRING function.static @NotNull Field<byte[]> binarySubstring(Field<byte[]> string,
Field<? extends Number> startingPosition,
Field<? extends Number> length) BINARY_SUBSTRING function.static @NotNull Field<byte[]> binaryTrim(byte[] bytes,
byte[] characters) BINARY_TRIM function.static @NotNull Field<byte[]> binaryTrim(byte[] bytes,
Field<byte[]> characters) BINARY_TRIM function.static @NotNull Field<byte[]> binaryTrim(Field<byte[]> bytes,
byte[] characters) BINARY_TRIM function.static @NotNull Field<byte[]> binaryTrim(Field<byte[]> bytes,
Field<byte[]> characters) BINARY_TRIM function.binToUuid(byte[] bytes) BIN_TO_UUID function.BIN_TO_UUID function.BIT_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 Catalogstatic @NotNull Field<BigDecimal> CBRT function.static @NotNull Field<BigDecimal> CBRT function.CEIL 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 RowCountQuerycommit()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 CreateSynonymForStepcreateOrReplacePublicSynonym(String synonym) CREATE OR REPLACE PUBLIC SYNONYM statement.static CreateSynonymForStepcreateOrReplacePublicSynonym(Name synonym) CREATE OR REPLACE PUBLIC SYNONYM statement.static CreateSynonymForStepcreateOrReplacePublicSynonym(Synonym synonym) CREATE OR REPLACE PUBLIC SYNONYM statement.static CreateSynonymForStepcreateOrReplaceSynonym(String synonym) CREATE OR REPLACE SYNONYM statement.static CreateSynonymForStepcreateOrReplaceSynonym(Name synonym) CREATE OR REPLACE SYNONYM statement.static CreateSynonymForStepcreateOrReplaceSynonym(Synonym synonym) CREATE OR REPLACE SYNONYM 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 CreateSynonymForStepcreatePublicSynonym(String synonym) CREATE PUBLIC SYNONYM statement.static CreateSynonymForStepcreatePublicSynonym(Name synonym) CREATE PUBLIC SYNONYM statement.static CreateSynonymForStepcreatePublicSynonym(Synonym synonym) CREATE PUBLIC SYNONYM 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 CreateSequenceAsStep<Number> createSequence(String sequence) CREATE SEQUENCE statement.static CreateSequenceAsStep<Number> createSequence(Name sequence) CREATE SEQUENCE statement.static CreateSequenceAsStep<Number> createSequence(Sequence<?> sequence) CREATE SEQUENCE statement.static CreateSequenceAsStep<Number> createSequenceIfNotExists(String sequence) CREATE SEQUENCE IF NOT EXISTS statement.static CreateSequenceAsStep<Number> createSequenceIfNotExists(Name sequence) CREATE SEQUENCE IF NOT EXISTS statement.static CreateSequenceAsStep<Number> createSequenceIfNotExists(Sequence<?> sequence) CREATE SEQUENCE IF NOT EXISTS statement.static CreateSynonymForStepcreateSynonym(String synonym) CREATE SYNONYM statement.static CreateSynonymForStepcreateSynonym(Name synonym) CREATE SYNONYM statement.static CreateSynonymForStepcreateSynonym(Synonym synonym) CREATE SYNONYM 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 function.static @NotNull OrderedAggregateFunction<BigDecimal> CUME_DIST 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 function.static @NotNull OrderedAggregateFunction<Integer> DENSE_RANK 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 DDLQuerydropPublicSynonym(String synonym) DROP PUBLIC SYNONYM statement.static DDLQuerydropPublicSynonym(Name synonym) DROP PUBLIC SYNONYM statement.static DDLQuerydropPublicSynonym(Synonym synonym) DROP PUBLIC SYNONYM statement.static DDLQuerydropPublicSynonymIfExists(String synonym) DROP PUBLIC SYNONYM IF EXISTS statement.static DDLQuerydropPublicSynonymIfExists(Name synonym) DROP PUBLIC SYNONYM IF EXISTS statement.static DDLQuerydropPublicSynonymIfExists(Synonym synonym) DROP PUBLIC SYNONYM 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 DDLQuerydropSynonym(String synonym) DROP SYNONYM statement.static DDLQuerydropSynonym(Name synonym) DROP SYNONYM statement.static DDLQuerydropSynonym(Synonym synonym) DROP SYNONYM statement.static DDLQuerydropSynonymIfExists(String synonym) DROP SYNONYM IF EXISTS statement.static DDLQuerydropSynonymIfExists(Name synonym) DROP SYNONYM IF EXISTS statement.static DDLQuerydropSynonymIfExists(Synonym synonym) DROP SYNONYM 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(String name,
Class<T> type,
Collection<? extends Field<?>> arguments) 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(String name,
DataType<T> type,
Collection<? extends Field<?>> arguments) 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(Name name,
Class<T> type,
Collection<? extends Field<?>> arguments) 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(Name name,
DataType<T> type,
Collection<? extends Field<?>> arguments) 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) jsonArrayLength(Field<JSON> field) JSON_ARRAY_LENGTH function.jsonArrayLength(JSON field) JSON_ARRAY_LENGTH function.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) jsonbArrayLength(Field<JSONB> field) JSONB_ARRAY_LENGTH function.jsonbArrayLength(JSONB field) JSONB_ARRAY_LENGTH function.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.static @NotNull ConditionjsonbKeyExists(Field<JSONB> json,
String key) JSONB_KEY_EXISTS function.static @NotNull ConditionjsonbKeyExists(Field<JSONB> json,
Field<String> key) JSONB_KEY_EXISTS function.static @NotNull ConditionjsonbKeyExists(JSONB json,
String key) JSONB_KEY_EXISTS function.static @NotNull ConditionjsonbKeyExists(JSONB json,
Field<String> key) JSONB_KEY_EXISTS 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.static @NotNull ConditionjsonKeyExists(Field<JSON> json,
String key) JSON_KEY_EXISTS function.static @NotNull ConditionjsonKeyExists(Field<JSON> json,
Field<String> key) JSON_KEY_EXISTS function.static @NotNull ConditionjsonKeyExists(JSON json,
String key) JSON_KEY_EXISTS function.static @NotNull ConditionjsonKeyExists(JSON json,
Field<String> key) JSON_KEY_EXISTS 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.lambda(Q1 arg1,
QR result) 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> static @NotNull OrderedAggregateFunction<String> listAggDistinct(Field<?> field) static @NotNull OrderedAggregateFunction<String> listAggDistinct(Field<?> field,
String separator) static @NotNull OrderedAggregateFunction<String> listAggDistinct(Field<?> 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 OptionallyOrderedAggregateFunction<T> MAX_BY 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 OptionallyOrderedAggregateFunction<T> MIN_BY 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 Path<?> noPath()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 percentile) PERCENTILE_CONT function.static @NotNull OrderedAggregateFunction<BigDecimal> percentileCont(Field<? extends Number> percentile) PERCENTILE_CONT function.static @NotNull OrderedAggregateFunction<BigDecimal> percentileDisc(Number percentile) PERCENTILE_DISC function.static @NotNull OrderedAggregateFunction<BigDecimal> percentileDisc(Field<? extends Number> percentile) PERCENTILE_DISC function.static @NotNull WindowOverStep<BigDecimal> percent_rank() over ([analytic clause]) function.static @NotNull OrderedAggregateFunction<BigDecimal> percentRank(Collection<? extends Field<?>> fields) PERCENT_RANK function.static @NotNull OrderedAggregateFunction<BigDecimal> percentRank(Field<?>... fields) PERCENT_RANK 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 function.static @NotNull OrderedAggregateFunction<Integer> RANK 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 RowCountQueryreleaseSavepoint(String name) RELEASE SAVEPOINT statement.static RowCountQueryreleaseSavepoint(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) static @NotNull Field<BigDecimal> ROOT function.static @NotNull Field<BigDecimal> ROOT function.static @NotNull Field<BigDecimal> ROOT function.static @NotNull Field<BigDecimal> ROOT function.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 RowCountQuerySAVEPOINT statement.static RowCountQuerySAVEPOINT 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 RowCountQuerySTART 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.stBoundary(Field<? extends Spatial> value) ST_BOUNDARY function.stBoundary(Spatial value) ST_BOUNDARY function.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.stCoveredBy(Field<T> arg1,
Field<T> arg2) ST_COVEREDBY function.stCoveredBy(Field<T> arg1,
T arg2) ST_COVEREDBY function.stCoveredBy(T arg1,
Field<T> arg2) ST_COVEREDBY function.stCoveredBy(T arg1,
T arg2) ST_COVEREDBY function.ST_COVERS function.ST_COVERS function.ST_COVERS function.stCovers(T arg1,
T arg2) ST_COVERS 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.stDimension(Field<? extends Spatial> value) ST_DIMENSION function.stDimension(Spatial value) ST_DIMENSION 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.static @NotNull ConditionST_ISRING function.static @NotNull ConditionST_ISRING function.static @NotNull ConditionstIsSimple(Field<? extends Spatial> value) ST_ISSIMPLE function.static @NotNull ConditionstIsSimple(Spatial value) ST_ISSIMPLE function.static @NotNull ConditionST_ISVALID function.static @NotNull ConditionST_ISVALID 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.stPerimeter(Field<T> value) ST_PERIMETER function.stPerimeter(T value) ST_PERIMETER function.ST_POINTN function.ST_POINTN function.stPointN(T value,
int position) ST_POINTN function.ST_POINTN function.static @NotNull OrderedAggregateFunction<String> static @NotNull OrderedAggregateFunction<String> static @NotNull OrderedAggregateFunction<String> static @NotNull OrderedAggregateFunction<String> stringAggDistinct(Field<?> field) static @NotNull OrderedAggregateFunction<String> stringAggDistinct(Field<?> field,
String separator) static @NotNull OrderedAggregateFunction<String> stringAggDistinct(Field<?> field,
Field<String> separator) stringToArray(String string,
String delimiter) STRING_TO_ARRAY function.stringToArray(String string,
String delimiter,
String nullString) STRING_TO_ARRAY function.stringToArray(Field<String> string,
Field<String> delimiter) STRING_TO_ARRAY function.STRING_TO_ARRAY 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.stTransform(Field<T> value,
int srid) ST_TRANSFORM function.stTransform(Field<T> value,
Field<? extends Number> srid) ST_TRANSFORM function.stTransform(T value,
int srid) ST_TRANSFORM function.stTransform(T value,
Field<? extends Number> srid) ST_TRANSFORM 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_XMAX function.ST_XMAX function.ST_XMIN function.ST_XMIN function.ST_Y function.ST_Y function.ST_YMAX function.ST_YMAX function.ST_YMIN function.ST_YMIN function.ST_Z function.ST_Z function.ST_ZMAX function.ST_ZMAX function.ST_ZMIN function.ST_ZMIN 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.static @NotNull Synonymstatic @NotNull SynonymsysConnectByPath(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.static @NotNull Field<byte[]> UUID_TO_BIN function.static @NotNull Field<byte[]> UUID_TO_BIN 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)
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.
CREATE SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 PUBLIC SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 PUBLIC SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 PUBLIC SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 PUBLIC SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 PUBLIC SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 PUBLIC SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 SYNONYM 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 SYNONYM 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 SYNONYM 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 PUBLIC SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 PUBLIC SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 PUBLIC SYNONYM statement.
Unlike statement construction methods in the DSLContext API, 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 PUBLIC SYNONYM 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 PUBLIC SYNONYM 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 PUBLIC SYNONYM 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.
Table that behaves like no Path 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 noPath()
can be used to avoid creating a FROM clause or a join
operation.
NOTE [#16918] that this Path 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.
A parameter renders itself differently, depending on
Context.declareParameters(). There are two rendering modes:
Parameter.getParamMode()
along with the parameter name and data type. This typically happens in
CREATE PROCEDURE or CREATE FUNCTION
clauses.IN parameter.
A parameter renders itself differently, depending on
Context.declareParameters(). There are two rendering modes:
Parameter.getParamMode()
along with the parameter name and data type. This typically happens in
CREATE PROCEDURE or CREATE FUNCTION
clauses.IN OUT parameter.
A parameter renders itself differently, depending on
Context.declareParameters(). There are two rendering modes:
Parameter.getParamMode()
along with the parameter name and data type. This typically happens in
CREATE PROCEDURE or CREATE FUNCTION
clauses.IN OUT parameter.
A parameter renders itself differently, depending on
Context.declareParameters(). There are two rendering modes:
Parameter.getParamMode()
along with the parameter name and data type. This typically happens in
CREATE PROCEDURE or CREATE FUNCTION
clauses.OUT parameter.
A parameter renders itself differently, depending on
Context.declareParameters(). There are two rendering modes:
Parameter.getParamMode()
along with the parameter name and data type. This typically happens in
CREATE PROCEDURE or CREATE FUNCTION
clauses.OUT parameter.
A parameter renders itself differently, depending on
Context.declareParameters(). There are two rendering modes:
Parameter.getParamMode()
along with the parameter name and data type. This typically happens in
CREATE PROCEDURE or CREATE FUNCTION
clauses.
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 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!
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.
Unlike with cast(Object, Field), 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,
// where a String is expected
DSL.val(1).coerce(VARCHAR);
// This binds an int value to a JDBC PreparedStatement
// and casts it to VARCHAR in SQL
DSL.val(1).cast(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
BOOK.ID.coerce(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
// after casting it to VARCHAR in the database
BOOK.ID.cast(VARCHAR);
Unlike with cast(Object, Class), 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,
// where a String is expected
DSL.val(1).coerce(VARCHAR);
// This binds an int value to a JDBC PreparedStatement
// and casts it to VARCHAR in SQL
DSL.val(1).cast(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
BOOK.ID.coerce(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
// after casting it to VARCHAR in the database
BOOK.ID.cast(VARCHAR);
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 cast(Object, DataType), 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,
// where a String is expected
DSL.val(1).coerce(VARCHAR);
// This binds an int value to a JDBC PreparedStatement
// and casts it to VARCHAR in SQL
DSL.val(1).cast(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
BOOK.ID.coerce(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
// after casting it to VARCHAR in the database
BOOK.ID.cast(VARCHAR);
Unlike with cast(Field, Field), 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,
// where a String is expected
DSL.val(1).coerce(VARCHAR);
// This binds an int value to a JDBC PreparedStatement
// and casts it to VARCHAR in SQL
DSL.val(1).cast(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
BOOK.ID.coerce(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
// after casting it to VARCHAR in the database
BOOK.ID.cast(VARCHAR);
T - The generic type of the coerced fieldfield - The field to be coercedas - The field whose type is used for the coercion
Unlike with cast(Field, Class), 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,
// where a String is expected
DSL.val(1).coerce(VARCHAR);
// This binds an int value to a JDBC PreparedStatement
// and casts it to VARCHAR in SQL
DSL.val(1).cast(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
BOOK.ID.coerce(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
// after casting it to VARCHAR in the database
BOOK.ID.cast(VARCHAR);
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 cast(Field, DataType), 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,
// where a String is expected
DSL.val(1).coerce(VARCHAR);
// This binds an int value to a JDBC PreparedStatement
// and casts it to VARCHAR in SQL
DSL.val(1).cast(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
BOOK.ID.coerce(VARCHAR);
// This fetches a String value for the BOOK.ID field from JDBC
// after casting it to VARCHAR in the database
BOOK.ID.cast(VARCHAR);
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 docs
Casting converts expressions between data types directly in SQL using SQL
CAST expressions or similar. If you want to convert data
types only in jOOQ without any effect on generated SQL, you can use
coerce(Object, Field) instead.
T - The generic type of the cast fieldvalue - The value to castas - The field whose type is used for the cast
Casting converts expressions between data types directly in SQL using SQL
CAST expressions or similar. If you want to convert data
types only in jOOQ without any effect on generated SQL, you can use
coerce(Field, Field) instead.
T - 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
Casting converts expressions between data types directly in SQL using SQL
CAST expressions or similar. If you want to convert data
types only in jOOQ without any effect on generated SQL, you can use
coerce(Object, Class) instead.
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)
Casting converts expressions between data types directly in SQL using SQL
CAST expressions or similar. If you want to convert data
types only in jOOQ without any effect on generated SQL, you can use
coerce(Field, Class) instead.
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 cast
Casting converts expressions between data types directly in SQL using SQL
CAST expressions or similar. If you want to convert data
types only in jOOQ without any effect on generated SQL, you can use
coerce(Object, DataType) instead.
T - The generic type of the cast fieldvalue - The value to casttype - The type that is used for the cast
Casting converts expressions between data types directly in SQL using SQL
CAST expressions or similar. If you want to convert data
types only in jOOQ without any effect on generated SQL, you can use
coerce(Field, DataType) instead.
T - 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.CBRT function.value - is wrapped as val(Object).CBRT 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.
ROOT function.value - is wrapped as val(Object).degree - is wrapped as val(Object).ROOT function.value - is wrapped as val(Object).ROOT function.degree - is wrapped as val(Object).ROOT