primaryKey
PRIMARY KEY
constraint.AccessDSL
, ASEDSL
, CUBRIDDSL
, DB2DSL
, DerbyDSL
, FirebirdDSL
, H2DSL
, HanaDSL
, HSQLDBDSL
, InformixDSL
, IngresDSL
, MariaDBDSL
, MySQLDSL
, OracleDSL
, PostgresDSL
, RedshiftDSL
, SQLiteDSL
, SQLServerDSL
, SybaseDSL
, VerticaDSL
org.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 AlterDatabaseStep
alterDatabase(String database)
ALTER DATABASE
statement.static AlterDatabaseStep
alterDatabase(Catalog database)
ALTER DATABASE
statement.static AlterDatabaseStep
alterDatabase(Name database)
ALTER DATABASE
statement.static AlterDatabaseStep
alterDatabaseIfExists(String database)
ALTER DATABASE IF EXISTS
statement.static AlterDatabaseStep
alterDatabaseIfExists(Catalog database)
ALTER DATABASE IF EXISTS
statement.static AlterDatabaseStep
alterDatabaseIfExists(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 AlterIndexOnStep
alterIndex(String index)
ALTER INDEX
statement.static AlterIndexOnStep
alterIndex(Index index)
ALTER INDEX
statement.static AlterIndexOnStep
alterIndex(Name index)
ALTER INDEX
statement.static AlterIndexOnStep
alterIndexIfExists(String index)
ALTER INDEX IF EXISTS
statement.static AlterIndexOnStep
alterIndexIfExists(Index index)
ALTER INDEX IF EXISTS
statement.static AlterIndexOnStep
alterIndexIfExists(Name index)
ALTER INDEX IF EXISTS
statement.static AlterSchemaStep
alterSchema(String schema)
ALTER SCHEMA
statement.static AlterSchemaStep
alterSchema(Name schema)
ALTER SCHEMA
statement.static AlterSchemaStep
alterSchema(Schema schema)
ALTER SCHEMA
statement.static AlterSchemaStep
alterSchemaIfExists(String schema)
ALTER SCHEMA IF EXISTS
statement.static AlterSchemaStep
alterSchemaIfExists(Name schema)
ALTER SCHEMA IF EXISTS
statement.static AlterSchemaStep
alterSchemaIfExists(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 AlterTableStep
alterTable(String table)
ALTER TABLE
statement.static @NotNull AlterTableStep
alterTable(Name table)
ALTER TABLE
statement.static @NotNull AlterTableStep
alterTable(Table<?> table)
ALTER TABLE
statement.static @NotNull AlterTableStep
alterTableIfExists(String table)
ALTER TABLE
statement.static @NotNull AlterTableStep
alterTableIfExists(Name table)
ALTER TABLE
statement.static @NotNull AlterTableStep
alterTableIfExists(Table<?> table)
ALTER TABLE
statement.static AlterTypeStep
ALTER TYPE
statement.static AlterTypeStep
ALTER TYPE
statement.static AlterViewStep
ALTER VIEW
statement.static AlterViewStep
ALTER VIEW
statement.static AlterViewStep
ALTER VIEW
statement.static AlterViewStep
alterViewIfExists(String view)
ALTER VIEW IF EXISTS
statement.static AlterViewStep
alterViewIfExists(Name view)
ALTER VIEW IF EXISTS
statement.static AlterViewStep
alterViewIfExists(Table<?> view)
ALTER VIEW IF EXISTS
statement.static @NotNull Condition
and(Collection<? extends Condition> conditions)
static @NotNull Condition
static @NotNull Condition
static <T> @NotNull QuantifiedSelect<Record1<T>>
ANY
quantified select to be used in quantified
comparison predicate expressions.static <T> @NotNull QuantifiedSelect<Record1<T>>
ANY
quantified select to be used in quantified
comparison predicate expressions.static <R extends Record>
@NotNull QuantifiedSelect<R>
ANY
quantified select to be used in quantified
comparison predicate expressions.static <T> @NotNull QuantifiedSelect<Record1<T>>
any(T... array)
ANY
quantified select to be used in quantified
comparison predicate expressions.static <T> @NotNull AggregateFunction<T>
ANY_VALUE
function.static <T> @NotNull Field<T[]>
array(Collection<? extends Field<T>> fields)
static <T> @NotNull Field<T[]>
static <T> @NotNull Field<T[]>
array(select)
function.static <T> @NotNull Field<T[]>
array(T... values)
static <T> @NotNull ArrayAggOrderByStep<T[]>
array_agg()
aggregate function.static <T> @NotNull ArrayAggOrderByStep<T[]>
arrayAggDistinct(Field<T> field)
array_agg()
aggregate function.static <T> @NotNull Field<T>
ARRAY_GET
function.static <T> @NotNull Field<T>
ARRAY_GET
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 Asterisk
asterisk()
*
) 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 Block
begin(Collection<? extends Statement> statements)
static @NotNull Block
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_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_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 CallArgsStep
CALL
statement.static CallArgsStep
CALL
statement.cardinality(Field<? extends Object[]> array)
CARDINALITY
function.static @NotNull Case
case_()
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 Catalog
static @NotNull Catalog
CEIL
function.ceil(T value)
CEIL
function.static @NotNull CharacterSet
characterSet(String characterSet)
static @NotNull CharacterSet
characterSet(Name characterSet)
charLength(String string)
CHAR_LENGTH
function.charLength(Field<String> string)
CHAR_LENGTH
function.static @NotNull ConstraintEnforcementStep
CHECK
constraint.static @NotNull Case
choose()
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 Collation
static @NotNull Collation
static <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 Comment
static CommentOnIsStep
commentOnColumn(String field)
COMMENT ON COLUMN
statement.static CommentOnIsStep
commentOnColumn(Field<?> field)
COMMENT ON COLUMN
statement.static CommentOnIsStep
commentOnColumn(Name field)
COMMENT ON COLUMN
statement.static CommentOnIsStep
commentOnTable(String table)
COMMENT ON TABLE
statement.static CommentOnIsStep
commentOnTable(Name table)
COMMENT ON TABLE
statement.static CommentOnIsStep
commentOnTable(Table<?> table)
COMMENT ON TABLE
statement.static CommentOnIsStep
commentOnView(String view)
COMMENT ON VIEW
statement.static CommentOnIsStep
commentOnView(Name view)
COMMENT ON VIEW
statement.static CommentOnIsStep
commentOnView(Table<?> view)
COMMENT ON VIEW
statement.concat(value, field)
function.concat(field, value)
function.static @NotNull Condition
static @NotNull Condition
static @NotNull Condition
static @NotNull Condition
static @NotNull Condition
static @NotNull Condition
CONDITION
function.static @NotNull Condition
condition(Operator operator,
Collection<? extends Condition> conditions)
Condition
that connects all argument
conditions
with Operator
.static @NotNull Condition
Condition
that connects all argument
conditions
with Operator
.static @NotNull Condition
Condition
that connects all argument
conditions
with Operator
.static @NotNull Condition
static @NotNull Condition
CONNECT_BY_ISCYCLE
function.CONNECT_BY_ISLEAF
function.static <T> @NotNull Field<T>
connectByRoot(Field<T> field)
CONNECT_BY_ROOT
function.static @NotNull ConstraintTypeStep
CONSTRAINT
specification.static @NotNull ConstraintTypeStep
constraint(String name)
CONSTRAINT
specification.static @NotNull ConstraintTypeStep
constraint(Name name)
CONSTRAINT
specification.static @NotNull ContinueWhenStep
CONTINUE
statement for use in procedural code.static @NotNull ContinueWhenStep
CONTINUE
statement for use in procedural code.static @NotNull Statement
continueWhen(Condition condition)
CONTINUE
statement for use in procedural code.static @NotNull Statement
continueWhen(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 CreateDatabaseFinalStep
createDatabase(String database)
CREATE DATABASE
statement.static CreateDatabaseFinalStep
createDatabase(Catalog database)
CREATE DATABASE
statement.static CreateDatabaseFinalStep
createDatabase(Name database)
CREATE DATABASE
statement.static CreateDatabaseFinalStep
createDatabaseIfNotExists(String database)
CREATE DATABASE IF NOT EXISTS
statement.static CreateDatabaseFinalStep
createDatabaseIfNotExists(Catalog database)
CREATE DATABASE IF NOT EXISTS
statement.static CreateDatabaseFinalStep
createDatabaseIfNotExists(Name database)
CREATE DATABASE IF NOT EXISTS
statement.static CreateDomainAsStep
createDomain(String domain)
CREATE DOMAIN
statement.static CreateDomainAsStep
createDomain(Domain<?> domain)
CREATE DOMAIN
statement.static CreateDomainAsStep
createDomain(Name domain)
CREATE DOMAIN
statement.static CreateDomainAsStep
createDomainIfNotExists(String domain)
CREATE DOMAIN IF NOT EXISTS
statement.static CreateDomainAsStep
createDomainIfNotExists(Domain<?> domain)
CREATE DOMAIN IF NOT EXISTS
statement.static CreateDomainAsStep
createDomainIfNotExists(Name domain)
CREATE DOMAIN IF NOT EXISTS
statement.static CreateFunctionParametersStep
createFunction(String function)
CREATE FUNCTION
statement.static CreateFunctionParametersStep
createFunction(Name function)
CREATE FUNCTION
statement.static CreateTableElementListStep
createGlobalTemporaryTable(String table)
CREATE GLOBAL TEMPORARY TABLE
statement.static CreateTableElementListStep
createGlobalTemporaryTable(Name table)
CREATE GLOBAL TEMPORARY TABLE
statement.static CreateTableElementListStep
createGlobalTemporaryTable(Table<?> table)
CREATE GLOBAL TEMPORARY TABLE
statement.static CreateTableElementListStep
CREATE GLOBAL TEMPORARY TABLE IF NOT EXISTS
statement.static CreateTableElementListStep
CREATE GLOBAL TEMPORARY TABLE IF NOT EXISTS
statement.static CreateTableElementListStep
createGlobalTemporaryTableIfNotExists(Table<?> table)
CREATE GLOBAL TEMPORARY TABLE IF NOT EXISTS
statement.static CreateIndexStep
CREATE INDEX
statement.static CreateIndexStep
createIndex(String index)
CREATE INDEX
statement.static CreateIndexStep
createIndex(Index index)
CREATE INDEX
statement.static CreateIndexStep
createIndex(Name index)
CREATE INDEX
statement.static CreateIndexStep
CREATE INDEX IF NOT EXISTS
statement.static CreateIndexStep
createIndexIfNotExists(String index)
CREATE INDEX IF NOT EXISTS
statement.static CreateIndexStep
createIndexIfNotExists(Index index)
CREATE INDEX IF NOT EXISTS
statement.static CreateIndexStep
createIndexIfNotExists(Name index)
CREATE INDEX IF NOT EXISTS
statement.static CreateFunctionParametersStep
createOrReplaceFunction(String function)
CREATE OR REPLACE FUNCTION
statement.static CreateFunctionParametersStep
createOrReplaceFunction(Name function)
CREATE OR REPLACE FUNCTION
statement.createOrReplaceProcedure(String procedure)
CREATE OR REPLACE PROCEDURE
statement.createOrReplaceProcedure(Name procedure)
CREATE OR REPLACE PROCEDURE
statement.static CreateTriggerEventStep
createOrReplaceTrigger(String trigger)
CREATE OR REPLACE TRIGGER
statement.static CreateTriggerEventStep
createOrReplaceTrigger(Name trigger)
CREATE OR REPLACE TRIGGER
statement.static @NotNull CreateViewAsStep
createOrReplaceView(String view,
String... fields)
CREATE OR REPLACE VIEW
statement.static @NotNull CreateViewAsStep
createOrReplaceView(String view,
Function<? super Field<?>,? extends String> fieldNameFunction)
static @NotNull CreateViewAsStep
createOrReplaceView(Name view,
Function<? super Field<?>,? extends Name> fieldNameFunction)
static @NotNull CreateViewAsStep
createOrReplaceView(Name view,
Name... fields)
CREATE OR REPLACE VIEW
statement.static @NotNull CreateViewAsStep
createOrReplaceView(Table<?> view,
Function<? super Field<?>,? extends Field<?>> fieldNameFunction)
static @NotNull CreateViewAsStep
createOrReplaceView(Table<?> view,
Field<?>... fields)
CREATE OR REPLACE VIEW
statement.createProcedure(String procedure)
CREATE PROCEDURE
statement.createProcedure(Name procedure)
CREATE PROCEDURE
statement.static CreateSchemaFinalStep
createSchema(String schema)
CREATE SCHEMA
statement.static CreateSchemaFinalStep
createSchema(Name schema)
CREATE SCHEMA
statement.static CreateSchemaFinalStep
createSchema(Schema schema)
CREATE SCHEMA
statement.static CreateSchemaFinalStep
createSchemaIfNotExists(String schema)
CREATE SCHEMA IF NOT EXISTS
statement.static CreateSchemaFinalStep
createSchemaIfNotExists(Name schema)
CREATE SCHEMA IF NOT EXISTS
statement.static CreateSchemaFinalStep
createSchemaIfNotExists(Schema schema)
CREATE SCHEMA IF NOT EXISTS
statement.static CreateSequenceFlagsStep
createSequence(String sequence)
CREATE SEQUENCE
statement.static CreateSequenceFlagsStep
createSequence(Name sequence)
CREATE SEQUENCE
statement.static CreateSequenceFlagsStep
createSequence(Sequence<?> sequence)
CREATE SEQUENCE
statement.static CreateSequenceFlagsStep
createSequenceIfNotExists(String sequence)
CREATE SEQUENCE IF NOT EXISTS
statement.static CreateSequenceFlagsStep
createSequenceIfNotExists(Name sequence)
CREATE SEQUENCE IF NOT EXISTS
statement.static CreateSequenceFlagsStep
createSequenceIfNotExists(Sequence<?> sequence)
CREATE SEQUENCE IF NOT EXISTS
statement.static CreateTableElementListStep
createTable(String table)
CREATE TABLE
statement.static CreateTableElementListStep
createTable(Name table)
CREATE TABLE
statement.static CreateTableElementListStep
createTable(Table<?> table)
CREATE TABLE
statement.static CreateTableElementListStep
createTableIfNotExists(String table)
CREATE TABLE IF NOT EXISTS
statement.static CreateTableElementListStep
createTableIfNotExists(Name table)
CREATE TABLE IF NOT EXISTS
statement.static CreateTableElementListStep
createTableIfNotExists(Table<?> table)
CREATE TABLE IF NOT EXISTS
statement.static CreateTableElementListStep
createTemporaryTable(String table)
CREATE TEMPORARY TABLE
statement.static CreateTableElementListStep
createTemporaryTable(Name table)
CREATE TEMPORARY TABLE
statement.static CreateTableElementListStep
createTemporaryTable(Table<?> table)
CREATE TEMPORARY TABLE
statement.static CreateTableElementListStep
CREATE TEMPORARY TABLE IF NOT EXISTS
statement.static CreateTableElementListStep
CREATE TEMPORARY TABLE IF NOT EXISTS
statement.static CreateTableElementListStep
createTemporaryTableIfNotExists(Table<?> table)
CREATE TEMPORARY TABLE IF NOT EXISTS
statement.static CreateTriggerEventStep
createTrigger(String trigger)
CREATE TRIGGER
statement.static CreateTriggerEventStep
createTrigger(Name trigger)
CREATE TRIGGER
statement.static @NotNull CreateTypeStep
createType(String type)
CREATE TYPE
statement.static @NotNull CreateTypeStep
createType(Name type)
CREATE TYPE
statement.static CreateIndexStep
CREATE UNIQUE INDEX
statement.static CreateIndexStep
createUniqueIndex(String index)
CREATE UNIQUE INDEX
statement.static CreateIndexStep
createUniqueIndex(Index index)
CREATE UNIQUE INDEX
statement.static CreateIndexStep
createUniqueIndex(Name index)
CREATE UNIQUE INDEX
statement.static CreateIndexStep
CREATE UNIQUE INDEX IF NOT EXISTS
statement.static CreateIndexStep
CREATE UNIQUE INDEX IF NOT EXISTS
statement.static CreateIndexStep
CREATE UNIQUE INDEX IF NOT EXISTS
statement.static CreateIndexStep
createUniqueIndexIfNotExists(Name index)
CREATE UNIQUE INDEX IF NOT EXISTS
statement.static @NotNull CreateViewAsStep
createView(String view,
String... fields)
CREATE VIEW
statement.static @NotNull CreateViewAsStep
createView(String view,
Function<? super Field<?>,? extends String> fieldNameFunction)
static @NotNull CreateViewAsStep
createView(Name view,
Function<? super Field<?>,? extends Name> fieldNameFunction)
static @NotNull CreateViewAsStep
createView(Name view,
Name... fields)
CREATE VIEW
statement.static @NotNull CreateViewAsStep
createView(Table<?> view,
Function<? super Field<?>,? extends Field<?>> fieldNameFunction)
static @NotNull CreateViewAsStep
createView(Table<?> view,
Field<?>... fields)
CREATE VIEW
statement.static @NotNull CreateViewAsStep
createViewIfNotExists(String view,
String... fields)
CREATE VIEW IF NOT EXISTS
statement.static @NotNull CreateViewAsStep
createViewIfNotExists(String view,
Function<? super Field<?>,? extends String> fieldNameFunction)
static @NotNull CreateViewAsStep
createViewIfNotExists(Name view,
Function<? super Field<?>,? extends Name> fieldNameFunction)
static @NotNull CreateViewAsStep
createViewIfNotExists(Name view,
Name... fields)
CREATE VIEW IF NOT EXISTS
statement.static @NotNull CreateViewAsStep
createViewIfNotExists(Table<?> view,
Function<? super Field<?>,? extends Field<?>> fieldNameFunction)
static @NotNull CreateViewAsStep
createViewIfNotExists(Table<?> view,
Field<?>... fields)
CREATE VIEW IF NOT EXISTS
statement.static @NotNull GroupField
static @NotNull GroupField
cube(FieldOrRow... fields)
static @NotNull WindowOverStep<BigDecimal>
cumeDist()
cume_dist() over ([analytic clause])
function.static @NotNull OrderedAggregateFunction<BigDecimal>
cumeDist(Collection<? extends Field<?>> fields)
cume_dist(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<BigDecimal>
cume_dist(expr) within group (order by [order clause])
ordered-set aggregate function.CURRENT_CATALOG
function.SQLDataType.DATE
type.SQLDataType.DATE
type.static @NotNull Field<LocalDateTime>
SQLDataType.TIMESTAMP
type.static @NotNull Field<LocalDateTime>
currentLocalDateTime(int precision)
SQLDataType.TIMESTAMP
type with the specified fractional
seconds precision.static @NotNull Field<LocalDateTime>
currentLocalDateTime(Field<Integer> precision)
SQLDataType.TIMESTAMP
type with the specified fractional
seconds precision.SQLDataType.TIME
type.static @NotNull Field<OffsetDateTime>
static @NotNull Field<OffsetTime>
CURRENT_SCHEMA
function.SQLDataType.TIME
type.SQLDataType.TIMESTAMP
type.currentTimestamp(int precision)
SQLDataType.TIMESTAMP
type with the specified fractional
seconds precision.currentTimestamp(Field<Integer> precision)
SQLDataType.TIMESTAMP
type with the specified fractional
seconds precision.CURRENT_USER
function.DATE
.DATE
.DATE
.DATE_ADD
function.DATE_ADD
function.DATE_ADD
function.DATE_ADD
function.DATE_ADD
function.DATE_ADD
function.DATE_ADD
function.DATE_ADD
function.endDate - startDate
in
number of days.endDate - startDate
in
number of days.endDate - startDate
in terms
of part
.endDate - startDate
in terms
of part
.endDate - startDate
in terms
of part
.endDate - startDate
in terms
of part
.endDate - startDate
in
number of days.endDate - startDate
in
number of days.static @NotNull Statement
declare(Collection<? extends Variable<?>> variables)
static @NotNull Statement
static <T> @NotNull Declaration<T>
static @NotNull Case
decode()
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 Condition
deleting()
DELETING
function.static @NotNull WindowOverStep<Integer>
dense_rank() over ([analytic clause])
function.static @NotNull OrderedAggregateFunction<Integer>
denseRank(Collection<? extends Field<?>> fields)
dense_rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<Integer>
dense_rank(expr) within group (order by [order clause])
ordered-set aggregate function.DIGITS
function.DIGITS
function.static @NotNull Domain<?>
DOMAIN
reference.static @NotNull Domain<?>
DOMAIN
reference.static DropDatabaseFinalStep
dropDatabase(String database)
DROP DATABASE
statement.static DropDatabaseFinalStep
dropDatabase(Catalog database)
DROP DATABASE
statement.static DropDatabaseFinalStep
dropDatabase(Name database)
DROP DATABASE
statement.static DropDatabaseFinalStep
dropDatabaseIfExists(String database)
DROP DATABASE IF EXISTS
statement.static DropDatabaseFinalStep
dropDatabaseIfExists(Catalog database)
DROP DATABASE IF EXISTS
statement.static DropDatabaseFinalStep
dropDatabaseIfExists(Name database)
DROP DATABASE IF EXISTS
statement.static DropDomainCascadeStep
dropDomain(String domain)
DROP DOMAIN
statement.static DropDomainCascadeStep
dropDomain(Domain<?> domain)
DROP DOMAIN
statement.static DropDomainCascadeStep
dropDomain(Name domain)
DROP DOMAIN
statement.static DropDomainCascadeStep
dropDomainIfExists(String domain)
DROP DOMAIN IF EXISTS
statement.static DropDomainCascadeStep
dropDomainIfExists(Domain<?> domain)
DROP DOMAIN IF EXISTS
statement.static DropDomainCascadeStep
dropDomainIfExists(Name domain)
DROP DOMAIN IF EXISTS
statement.static DDLQuery
dropFunction(String function)
DROP FUNCTION
statement.static DDLQuery
dropFunction(Name function)
DROP FUNCTION
statement.static DDLQuery
dropFunctionIfExists(String function)
DROP FUNCTION IF EXISTS
statement.static DDLQuery
dropFunctionIfExists(Name function)
DROP FUNCTION IF EXISTS
statement.static DropIndexOnStep
DROP INDEX
statement.static DropIndexOnStep
DROP INDEX
statement.static DropIndexOnStep
DROP INDEX
statement.static DropIndexOnStep
dropIndexIfExists(String index)
DROP INDEX IF EXISTS
statement.static DropIndexOnStep
dropIndexIfExists(Index index)
DROP INDEX IF EXISTS
statement.static DropIndexOnStep
dropIndexIfExists(Name index)
DROP INDEX IF EXISTS
statement.static DDLQuery
dropProcedure(String procedure)
DROP PROCEDURE
statement.static DDLQuery
dropProcedure(Name procedure)
DROP PROCEDURE
statement.static DDLQuery
dropProcedureIfExists(String procedure)
DROP PROCEDURE IF EXISTS
statement.static DDLQuery
dropProcedureIfExists(Name procedure)
DROP PROCEDURE IF EXISTS
statement.static DropSchemaStep
dropSchema(String schema)
DROP SCHEMA
statement.static DropSchemaStep
dropSchema(Name schema)
DROP SCHEMA
statement.static DropSchemaStep
dropSchema(Schema schema)
DROP SCHEMA
statement.static DropSchemaStep
dropSchemaIfExists(String schema)
DROP SCHEMA IF EXISTS
statement.static DropSchemaStep
dropSchemaIfExists(Name schema)
DROP SCHEMA IF EXISTS
statement.static DropSchemaStep
dropSchemaIfExists(Schema schema)
DROP SCHEMA IF EXISTS
statement.static DropSequenceFinalStep
dropSequence(String sequence)
DROP SEQUENCE
statement.static DropSequenceFinalStep
dropSequence(Name sequence)
DROP SEQUENCE
statement.static DropSequenceFinalStep
dropSequence(Sequence<?> sequence)
DROP SEQUENCE
statement.static DropSequenceFinalStep
dropSequenceIfExists(String sequence)
DROP SEQUENCE IF EXISTS
statement.static DropSequenceFinalStep
dropSequenceIfExists(Name sequence)
DROP SEQUENCE IF EXISTS
statement.static DropSequenceFinalStep
dropSequenceIfExists(Sequence<?> sequence)
DROP SEQUENCE IF EXISTS
statement.static DropTableStep
DROP TABLE
statement.static DropTableStep
DROP TABLE
statement.static DropTableStep
DROP TABLE
statement.static DropTableStep
dropTableIfExists(String table)
DROP TABLE IF EXISTS
statement.static DropTableStep
dropTableIfExists(Name table)
DROP TABLE IF EXISTS
statement.static DropTableStep
dropTableIfExists(Table<?> table)
DROP TABLE IF EXISTS
statement.static DropTableStep
dropTemporaryTable(String table)
DROP TEMPORARY TABLE
statement.static DropTableStep
dropTemporaryTable(Name table)
DROP TEMPORARY TABLE
statement.static DropTableStep
dropTemporaryTable(Table<?> table)
DROP TEMPORARY TABLE
statement.static DropTableStep
dropTemporaryTableIfExists(String table)
DROP TEMPORARY TABLE IF EXISTS
statement.static DropTableStep
dropTemporaryTableIfExists(Name table)
DROP TEMPORARY TABLE IF EXISTS
statement.static DropTableStep
dropTemporaryTableIfExists(Table<?> table)
DROP TEMPORARY TABLE IF EXISTS
statement.static DDLQuery
dropTrigger(String trigger)
DROP TRIGGER
statement.static DDLQuery
dropTrigger(Name trigger)
DROP TRIGGER
statement.static DDLQuery
dropTriggerIfExists(String trigger)
DROP TRIGGER IF EXISTS
statement.static DDLQuery
dropTriggerIfExists(Name trigger)
DROP TRIGGER IF EXISTS
statement.static @NotNull DropTypeStep
DROP TYPE
statement.static @NotNull DropTypeStep
DROP TYPE
statement.static @NotNull DropTypeStep
dropType(Collection<?> type)
DROP TYPE
statement.static @NotNull DropTypeStep
DROP TYPE
statement.static @NotNull DropTypeStep
DROP TYPE
statement.static @NotNull DropTypeStep
dropTypeIfExists(String type)
DROP TYPE
statement.static @NotNull DropTypeStep
dropTypeIfExists(String... type)
DROP TYPE
statement.static @NotNull DropTypeStep
dropTypeIfExists(Collection<?> type)
DROP TYPE
statement.static @NotNull DropTypeStep
dropTypeIfExists(Name type)
DROP TYPE
statement.static @NotNull DropTypeStep
dropTypeIfExists(Name... type)
DROP TYPE
statement.static DropViewFinalStep
DROP VIEW
statement.static DropViewFinalStep
DROP VIEW
statement.static DropViewFinalStep
DROP VIEW
statement.static DropViewFinalStep
dropViewIfExists(String view)
DROP VIEW IF EXISTS
statement.static DropViewFinalStep
dropViewIfExists(Name view)
DROP VIEW IF EXISTS
statement.static DropViewFinalStep
dropViewIfExists(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 GroupField
static @NotNull String
replace(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 Statement
EXECUTE
function.static @NotNull Statement
EXECUTE
function.static @NotNull Statement
static @NotNull Condition
EXISTS
function.static @NotNull ExitWhenStep
exit()
EXIT
statement for use in procedural code.static @NotNull ExitWhenStep
EXIT
statement for use in procedural code.static @NotNull Statement
EXIT
statement for use in procedural code.static @NotNull Statement
EXIT
statement for use in procedural code.static @NotNull Field<BigDecimal>
EXP
function.static @NotNull Field<BigDecimal>
EXP
function.static @NotNull False
Condition
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 Field
static <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 ConstraintForeignKeyReferencesStepN
foreignKey(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 ConstraintForeignKeyReferencesStepN
foreignKey(Collection<? extends Field<?>> fields)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStepN
foreignKey(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 ConstraintForeignKeyReferencesStepN
foreignKey(Name... fields)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep2<?,?>
foreignKey(Name field1,
Name field2)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep3<?,?,?>
foreignKey(Name field1,
Name field2,
Name field3)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep4<?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep5<?,?,?,?,?>
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep6<?,?,?,?,?,?>
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep7<?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep8<?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep9<?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep10<?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep11<?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep12<?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep13<?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep14<?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep15<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep16<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep17<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep18<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17,
Name field18)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep19<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17,
Name field18,
Name field19)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep20<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17,
Name field18,
Name field19,
Name field20)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep21<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17,
Name field18,
Name field19,
Name field20,
Name field21)
FOREIGN KEY
clause to the CONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep22<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1,
Name field2,
Name field3,
Name field4,
Name field5,
Name field6,
Name field7,
Name field8,
Name field9,
Name field10,
Name field11,
Name field12,
Name field13,
Name field14,
Name field15,
Name field16,
Name field17,
Name field18,
Name field19,
Name field20,
Name field21,
Name field22)
FOREIGN KEY
clause to the CONSTRAINT
.static <T> @NotNull Field<T>
function()
can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull Field<T>
function()
can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull Field<T>
function()
can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull Field<T>
function()
can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.generateSeries(int from,
int to)
from
to
to
(inclusive).generateSeries(int from,
int to,
int step)
from
to
to
(inclusive), increasing values by step
.generateSeries(int from,
int to,
Field<Integer> step)
from
to
to
(inclusive), increasing values by step
.generateSeries(int from,
Field<Integer> to)
from
to
to
(inclusive).generateSeries(int from,
Field<Integer> to,
int step)
from
to
to
(inclusive), increasing values by step
.generateSeries(int from,
Field<Integer> to,
Field<Integer> step)
from
to
to
(inclusive), increasing values by step
.generateSeries(Field<Integer> from,
int to)
from
to
to
(inclusive).generateSeries(Field<Integer> from,
int to,
int step)
from
to
to
(inclusive), increasing values by step
.generateSeries(Field<Integer> from,
int to,
Field<Integer> step)
from
to
to
(inclusive), increasing values by step
.generateSeries(Field<Integer> from,
Field<Integer> to)
from
to
to
(inclusive).generateSeries(Field<Integer> from,
Field<Integer> to,
int step)
from
to
to
(inclusive), increasing values by step
.from
to
to
(inclusive), increasing values by step
.static <T> @NotNull DataType<T>
getDataType(Class<T> type)
static @NotNull Statement
GOTO
function.static GrantOnStep
grant(Collection<? extends Privilege> privileges)
GRANT
statement.static GrantOnStep
GRANT
statement.static GrantOnStep
GRANT
statement.static <T> @NotNull Field<T>
static <T> @NotNull Field<T>
greatest(T value,
T... values)
static @NotNull GroupConcatOrderByStep
groupConcat(Field<?> field)
static @NotNull AggregateFunction<String>
groupConcat(Field<?> field,
String separator)
groupConcat(Field)
and
GroupConcatSeparatorStep.separator(String)
instead.static @NotNull GroupConcatOrderByStep
groupConcatDistinct(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 GroupField
groupingSets(Collection<? extends Field<?>>... fieldSets)
static @NotNull GroupField
groupingSets(Field<?>... fields)
static @NotNull GroupField
groupingSets(Field<?>[]... fieldSets)
static @NotNull WindowSpecificationRowsAndStep
WindowSpecification
with a GROUPS
clause.static @NotNull WindowSpecificationRowsAndStep
groupsBetweenFollowing(int number)
WindowSpecification
with a GROUPS
clause.static @NotNull WindowSpecificationRowsAndStep
groupsBetweenPreceding(int number)
WindowSpecification
with a GROUPS
clause.static @NotNull WindowSpecificationRowsAndStep
WindowSpecification
with a GROUPS
clause.static @NotNull WindowSpecificationRowsAndStep
WindowSpecification
with a GROUPS
clause.static @NotNull WindowSpecificationExcludeStep
WindowSpecification
with a GROUPS
clause.static @NotNull WindowSpecificationExcludeStep
groupsFollowing(int number)
WindowSpecification
with a GROUPS
clause.static @NotNull WindowSpecificationExcludeStep
groupsPreceding(int number)
WindowSpecification
with a GROUPS
clause.static @NotNull WindowSpecificationExcludeStep
WindowSpecification
with a GROUPS
clause.static @NotNull WindowSpecificationExcludeStep
WindowSpecification
with a GROUPS
clause.static @NotNull IfThenStep
IF
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 Index
inline(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 Condition
Condition
.static <T> @NotNull Field<T>
Field
.static @NotNull QueryPart
QueryPart
.static @NotNull Statement
Statement
.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 Condition
INSERTING
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 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 JSONExistsOnStep
jsonbExists(Field<JSONB> field,
String path)
static @NotNull JSONExistsOnStep
jsonbExists(Field<JSONB> field,
Field<String> path)
static @NotNull JSONObjectNullStep<JSONB>
static @NotNull JSONObjectNullStep<JSONB>
jsonbObject(Collection<? extends JSONEntry<?>> entries)
JSONB_OBJECT
function.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)
static @NotNull JSONTableColumnsFirstStep
jsonbTable(Field<JSONB> json,
Field<String> path)
static @NotNull JSONTableColumnsFirstStep
jsonbTable(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 JSONExistsOnStep
jsonExists(Field<JSON> field,
String path)
static @NotNull JSONExistsOnStep
jsonExists(Field<JSON> field,
Field<String> path)
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)
static @NotNull JSONTableColumnsFirstStep
static @NotNull JSONTableColumnsFirstStep
static @NotNull JSONValueOnStep<JSON>
static @NotNull JSONValueOnStep<JSON>
static @NotNull JSONEntryValueStep
jsonObject(JSONEntry...)
.static @NotNull JSONEntryValueStep
jsonObject(JSONEntry...)
.static @NotNull Keyword
static @NotNull Label
static @NotNull Label
static <T> @NotNull WindowIgnoreNullsStep<T>
lag(field) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lag(field, offset) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lag(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lag(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lag(field, offset) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lag(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lag(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
last_value(field) over ([analytic clause])
function.LATERAL
joined table.static <T> @NotNull WindowIgnoreNullsStep<T>
lead(field) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lead(field, offset) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lead(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lead(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lead(field, offset) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lead(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lead(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull Field<T>
static <T> @NotNull Field<T>
least(T value,
T... values)
LEFT
function.LEFT
function.LEFT
function.LEFT
function.LENGTH
function, an alias for the CHAR_LENGTH
function.LENGTH
function, an alias for the CHAR_LENGTH
function.level()
LEVEL
function.static @NotNull Link
static @NotNull Link
static @NotNull Link
static @NotNull QueryPart
list(Collection<? extends QueryPart> parts)
QueryParts
into a new
QueryPart
, with individual parts being comma-separated.static @NotNull QueryPart
QueryParts
into a new
QueryPart
, with individual parts being comma-separated.static @NotNull OrderedAggregateFunction<String>
static @NotNull OrderedAggregateFunction<String>
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 Statement
loop(Collection<? extends Statement> statements)
LOOP
for use in procedural code.static @NotNull Statement
LOOP
for use in procedural code.LOWER
function.LOWER
function.LPAD
function.LPAD
function.LPAD
function.LPAD
function.LPAD
function.LPAD
function.LTRIM
function.LTRIM
function.LTRIM
function.LTRIM
function.LTRIM
function.LTRIM
function.static <T> @NotNull AggregateFunction<T>
MAX
function.static <T> @NotNull AggregateFunction<T>
maxDistinct(Field<T> field)
MAX_DISTINCT
function.MD5
function.MD5
function.static @NotNull AggregateFunction<BigDecimal>
MEDIAN
function.static <R extends Record>
@NotNull MergeUsingStep<R>
static <R extends Record>
@NotNull MergeKeyStepN<R>
mergeInto(Table<R> table,
Collection<? extends Field<?>> fields)
mergeInto(Table)
static <R extends Record>
@NotNull MergeKeyStepN<R>
mergeInto(Table)
static <R extends Record,
T1>
@NotNull MergeKeyStep1<R,T1>
mergeInto(Table)
static <R extends Record,
T1,
T2>
@NotNull MergeKeyStep2<R,T1,T2>
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3>
@NotNull MergeKeyStep3<R,T1,T2,T3>
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4>
@NotNull MergeKeyStep4<R,T1,T2,T3,T4>
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5>
@NotNull MergeKeyStep5<R,T1,T2,T3,T4,T5>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6>
@NotNull MergeKeyStep6<R,T1,T2,T3,T4,T5,T6>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7>
@NotNull MergeKeyStep7<R,T1,T2,T3,T4,T5,T6,T7>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8>
@NotNull MergeKeyStep8<R,T1,T2,T3,T4,T5,T6,T7,T8>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9>
@NotNull MergeKeyStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull MergeKeyStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull MergeKeyStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull MergeKeyStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull MergeKeyStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull MergeKeyStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull MergeKeyStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull MergeKeyStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull MergeKeyStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull MergeKeyStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull MergeKeyStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull MergeKeyStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull MergeKeyStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21)
mergeInto(Table)
static <R extends Record,
T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull MergeKeyStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21,
Field<T22> field22)
mergeInto(Table)
microsecond(Temporal value)
microsecond(Date value)
microsecond(Field<?> field)
MID
function, an alias for the SUBSTRING
function.MID
function, an alias for the SUBSTRING
function.MID
function, an alias for the SUBSTRING
function.MID
function, an alias for the SUBSTRING
function.MID
function, an alias for the SUBSTRING
function.MID
function, an alias for the SUBSTRING
function.millennium(Temporal value)
millennium(Date value)
millennium(Field<?> field)
millisecond(Temporal value)
millisecond(Date value)
millisecond(Field<?> field)
static <T> @NotNull AggregateFunction<T>
MIN
function.static <T> @NotNull AggregateFunction<T>
minDistinct(Field<T> field)
MIN_DISTINCT
function.static @NotNull OrderedAggregateFunctionOfDeferredType
mode()
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 Field<?>> fields)
MULTISET_AGG
aggregate function to nest group
contents.static @NotNull ArrayAggOrderByStep<Result<Record>>
multisetAgg(Field<?>... 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 Name
static @NotNull Name
static @NotNull Name
name(Collection<String> qualifiedName)
static @NotNull Name
static @NotNull Condition
Condition
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 Condition
NOT
function.NOT
function.static @NotNull Condition
NOT EXISTS
function.static @NotNull Condition
NOT 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 Null
Condition
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 Condition
or(Collection<? extends Condition> conditions)
static @NotNull Condition
static @NotNull Condition
static @NotNull WindowSpecificationRowsStep
orderBy(Collection<? extends OrderField<?>> fields)
WindowSpecification
with an ORDER BY
clause.static @NotNull WindowSpecificationRowsStep
WindowSpecification
with an ORDER BY
clause.static @NotNull WindowSpecificationRowsStep
orderBy(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 WindowSpecificationOrderByStep
partitionBy(Collection<? extends Field<?>> fields)
WindowSpecification
with a PARTITION BY
clause.static @NotNull WindowSpecificationOrderByStep
partitionBy(Field<?>... fields)
WindowSpecification
with a PARTITION BY
clause.static @NotNull OrderedAggregateFunction<BigDecimal>
percentileCont(Number number)
percentile_cont([number]) within group (order by [column])
function.static @NotNull OrderedAggregateFunction<BigDecimal>
percentileCont(Field<? extends Number> field)
percentile_cont([number]) within group (order by [column])
function.static @NotNull OrderedAggregateFunction<BigDecimal>
percentileDisc(Number number)
percentile_disc([number]) within group (order by [column])
function.static @NotNull OrderedAggregateFunction<BigDecimal>
percentileDisc(Field<? extends Number> field)
percentile_disc([number]) within group (order by [column])
function.static @NotNull WindowOverStep<BigDecimal>
precent_rank() over ([analytic clause])
function.static @NotNull OrderedAggregateFunction<Integer>
percentRank(Collection<? extends Field<?>> fields)
percent_rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<Integer>
percentRank(Field<?>... fields)
percent_rank(expr) within group (order by [order clause])
ordered-set aggregate function.Period
reference.static <T> @NotNull Period<T>
Period
reference.static <T> @NotNull Period<T>
Period
reference.static @NotNull Field<BigDecimal>
pi()
PI
function.POSITION
function.POSITION
function.POSITION
function.POSITION
function.POSITION
function.POSITION
function.POSITION
function.POSITION
function.POSITION
function.POSITION
function.POSITION
function.POSITION
function.static @NotNull Field<BigDecimal>
POWER
function.static @NotNull Field<BigDecimal>
POWER
function.static @NotNull Field<BigDecimal>
POWER
function.static @NotNull Field<BigDecimal>
POWER
function.static @NotNull ConstraintEnforcementStep
primaryKey(String... fields)
PRIMARY KEY
constraint.static @NotNull ConstraintEnforcementStep
primaryKey(Collection<? extends Field<?>> fields)
PRIMARY KEY
constraint.static @NotNull ConstraintEnforcementStep
primaryKey(Field<?>... fields)
PRIMARY KEY
constraint.static @NotNull ConstraintEnforcementStep
primaryKey(Name... fields)
PRIMARY KEY
constraint.static <T> @NotNull Field<T>
PRIOR
function.static @NotNull Privilege
static @NotNull AggregateFunction<BigDecimal>
PRODUCT
function.static @NotNull AggregateFunction<BigDecimal>
productDistinct(Field<? extends Number> field)
PRODUCT_DISTINCT
function.static @NotNull Queries
queries(Collection<? extends Query> queries)
static @NotNull Queries
static @NotNull RowCountQuery
static @NotNull RowCountQuery
static @NotNull RowCountQuery
static @NotNull RowCountQuery
static @NotNull Name
quotedName(String unqualifiedName)
static @NotNull Name
quotedName(String... qualifiedName)
static @NotNull Name
quotedName(Collection<String> qualifiedName)
static @NotNull Field<BigDecimal>
RADIANS
function.static @NotNull Field<BigDecimal>
RADIANS
function.static @NotNull Field<BigDecimal>
rand()
RAND
function.static @NotNull WindowSpecificationRowsAndStep
WindowSpecification
with a RANGE
clause.static @NotNull WindowSpecificationRowsAndStep
rangeBetweenFollowing(int number)
WindowSpecification
with a RANGE
clause.static @NotNull WindowSpecificationRowsAndStep
rangeBetweenPreceding(int number)
WindowSpecification
with a RANGE
clause.static @NotNull WindowSpecificationRowsAndStep
WindowSpecification
with a RANGE
clause.static @NotNull WindowSpecificationRowsAndStep
WindowSpecification
with a RANGE
clause.static @NotNull WindowSpecificationExcludeStep
WindowSpecification
with a RANGE
clause.static @NotNull WindowSpecificationExcludeStep
rangeFollowing(int number)
WindowSpecification
with a RANGE
clause.static @NotNull WindowSpecificationExcludeStep
rangePreceding(int number)
WindowSpecification
with a RANGE
clause.static @NotNull WindowSpecificationExcludeStep
WindowSpecification
with a RANGE
clause.static @NotNull WindowSpecificationExcludeStep
WindowSpecification
with a RANGE
clause.static @NotNull WindowOverStep<Integer>
rank()
rank() over ([analytic clause])
function.static @NotNull OrderedAggregateFunction<Integer>
rank(Collection<? extends Field<?>> fields)
rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<Integer>
rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull WindowOverStep<BigDecimal>
ratioToReport(Number number)
ratio_to_report([expression]) over ([analytic clause])
function.static @NotNull WindowOverStep<BigDecimal>
ratioToReport(Field<? extends Number> field)
ratio_to_report([expression]) over ([analytic clause])
function.static <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_ALL
function.REGEXP_REPLACE_ALL
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.REPEAT
function.REPEAT
function.static @NotNull RepeatUntilStep
repeat(Collection<? extends Statement> statements)
REPEAT
loop for use in procedural code.REPEAT
function.REPEAT
function.static @NotNull RepeatUntilStep
REPEAT
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 Statement
return_()
RETURN_
function.static @NotNull Statement
RETURN_
function.static @NotNull Statement
RETURN_
function.REVERSE
function.REVERSE
function.static RevokeOnStep
revoke(Collection<? extends Privilege> privileges)
REVOKE
statement.static RevokeOnStep
REVOKE
statement.static RevokeOnStep
REVOKE
statement.static RevokeOnStep
revokeGrantOptionFor(Collection<? extends Privilege> privileges)
REVOKE GRANT OPTION FOR
statement.static RevokeOnStep
revokeGrantOptionFor(Privilege privileges)
REVOKE GRANT OPTION FOR
statement.static RevokeOnStep
revokeGrantOptionFor(Privilege... privileges)
REVOKE GRANT OPTION FOR
statement.RIGHT
function.RIGHT
function.RIGHT
function.RIGHT
function.static @NotNull Role
static @NotNull Role
static @NotNull GroupField
static @NotNull GroupField
rollup(FieldOrRow... fields)
ROUND
function.ROUND
function.ROUND
function.round(T value)
ROUND
function.round(T value,
int decimals)
ROUND
function.ROUND
function.static @NotNull RowN
N > 22
.static @NotNull RowN
row(Collection<?> values)
N > 22
.static @NotNull RowN
row(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 WindowSpecificationRowsAndStep
WindowSpecification
with a ROWS
clause.static @NotNull WindowSpecificationRowsAndStep
rowsBetweenFollowing(int number)
WindowSpecification
with a ROWS
clause.static @NotNull WindowSpecificationRowsAndStep
rowsBetweenPreceding(int number)
WindowSpecification
with a ROWS
clause.static @NotNull WindowSpecificationRowsAndStep
WindowSpecification
with a ROWS
clause.static @NotNull WindowSpecificationRowsAndStep
WindowSpecification
with a ROWS
clause.static @NotNull WindowSpecificationExcludeStep
WindowSpecification
with a ROWS
clause.static @NotNull WindowSpecificationExcludeStep
rowsFollowing(int number)
WindowSpecification
with a ROWS
clause.ROWS FROM (tables…)
expression.static @NotNull WindowSpecificationExcludeStep
rowsPreceding(int number)
WindowSpecification
with a ROWS
clause.static @NotNull WindowSpecificationExcludeStep
WindowSpecification
with a ROWS
clause.static @NotNull WindowSpecificationExcludeStep
WindowSpecification
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 @NotNull Schema
static @NotNull Schema
static @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 RowCountQuery
SET
statement.static RowCountQuery
setCatalog(String catalog)
SET CATALOG
statement.static RowCountQuery
setCatalog(Catalog catalog)
SET CATALOG
statement.static RowCountQuery
setCatalog(Name catalog)
SET CATALOG
statement.static RowCountQuery
SET LOCAL
statement.static RowCountQuery
SET SCHEMA
statement.static RowCountQuery
SET SCHEMA
statement.static RowCountQuery
SET SCHEMA
statement.SHL
function.SHL
function.SHL
function.SHL
function.SHR
function.SHR
function.SHR
function.SHR
function.SIGN
function.SIGN
function.static SignalSetStep
signalSQLState(Object value)
SIGNAL_SQLSTATE
function.static SignalSetStep
signalSQLState(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 SQL
static @NotNull SQL
static @NotNull SQL
static @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 @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 Statement
static @NotNull Statement
static @NotNull Statement
static @NotNull Statement
static @NotNull Block
statements(Collection<? extends Statement> statements)
BEGIN … END;
, unless explicitly needed.static @NotNull Block
statements(Statement... statements)
BEGIN … END;
, unless explicitly needed.stCentroid(Field<Geometry> value)
ST_CENTROID
function.stCentroid(Geometry value)
ST_CENTROID
function.stContains(Field<T> arg1,
Field<T> arg2)
ST_CONTAINS
function.stContains(Field<T> arg1,
T arg2)
ST_CONTAINS
function.stContains(T arg1,
Field<T> arg2)
ST_CONTAINS
function.stContains(T arg1,
T arg2)
ST_CONTAINS
function.static @NotNull Condition
ST_CROSSES
function.static @NotNull Condition
ST_CROSSES
function.static @NotNull Condition
ST_CROSSES
function.static @NotNull Condition
ST_CROSSES
function.static @NotNull AggregateFunction<BigDecimal>
STDDEV_POP
function.static @NotNull AggregateFunction<BigDecimal>
stddevSamp(Field<? extends Number> field)
STDDEV_SAMP
function.stDifference(Field<T> arg1,
Field<T> arg2)
ST_DIFFERENCE
function.stDifference(Field<T> arg1,
T arg2)
ST_DIFFERENCE
function.stDifference(T arg1,
Field<T> arg2)
ST_DIFFERENCE
function.stDifference(T arg1,
T arg2)
ST_DIFFERENCE
function.stDisjoint(Field<T> arg1,
Field<T> arg2)
ST_DISJOINT
function.stDisjoint(Field<T> arg1,
T arg2)
ST_DISJOINT
function.stDisjoint(T arg1,
Field<T> arg2)
ST_DISJOINT
function.stDisjoint(T arg1,
T arg2)
ST_DISJOINT
function.stDistance(Field<T> arg1,
Field<T> arg2)
ST_DISTANCE
function.stDistance(Field<T> arg1,
T arg2)
ST_DISTANCE
function.stDistance(T arg1,
Field<T> arg2)
ST_DISTANCE
function.stDistance(T arg1,
T arg2)
ST_DISTANCE
function.stEndPoint(Field<T> value)
ST_ENDPOINT
function.stEndPoint(T value)
ST_ENDPOINT
function.ST_EQUALS
function.ST_EQUALS
function.ST_EQUALS
function.stEquals(T arg1,
T arg2)
ST_EQUALS
function.stExteriorRing(Field<Geometry> value)
ST_EXTERIORRING
function.stExteriorRing(Geometry value)
ST_EXTERIORRING
function.stGeometryN(Field<T> value,
int position)
ST_GEOMETRYN
function.stGeometryN(Field<T> value,
Field<? extends Number> position)
ST_GEOMETRYN
function.stGeometryN(T value,
int position)
ST_GEOMETRYN
function.stGeometryN(T value,
Field<? extends Number> position)
ST_GEOMETRYN
function.stGeometryType(Field<? extends Spatial> value)
ST_GEOMETRYTYPE
function.stGeometryType(Spatial value)
ST_GEOMETRYTYPE
function.stGeomFromText(String text)
ST_GEOMFROMTEXT
function.stGeomFromText(String text,
int srid)
ST_GEOMFROMTEXT
function.stGeomFromText(String text,
Field<? extends Number> srid)
ST_GEOMFROMTEXT
function.stGeomFromText(Field<String> text)
ST_GEOMFROMTEXT
function.stGeomFromText(Field<String> text,
int srid)
ST_GEOMFROMTEXT
function.stGeomFromText(Field<String> text,
Field<? extends Number> srid)
ST_GEOMFROMTEXT
function.stGeomFromWKB(byte[] wkb)
ST_GEOMFROMWKB
function.stGeomFromWKB(byte[] wkb,
int srid)
ST_GEOMFROMWKB
function.stGeomFromWKB(byte[] wkb,
Field<? extends Number> srid)
ST_GEOMFROMWKB
function.stGeomFromWKB(Field<byte[]> wkb)
ST_GEOMFROMWKB
function.stGeomFromWKB(Field<byte[]> wkb,
int srid)
ST_GEOMFROMWKB
function.stGeomFromWKB(Field<byte[]> wkb,
Field<? extends Number> srid)
ST_GEOMFROMWKB
function.stInteriorRingN(Field<Geometry> value,
int position)
ST_INTERIORRINGN
function.stInteriorRingN(Field<Geometry> value,
Field<? extends Number> position)
ST_INTERIORRINGN
function.stInteriorRingN(Geometry value,
int position)
ST_INTERIORRINGN
function.stInteriorRingN(Geometry value,
Field<? extends Number> position)
ST_INTERIORRINGN
function.stIntersection(Field<T> arg1,
Field<T> arg2)
ST_INTERSECTION
function.stIntersection(Field<T> arg1,
T arg2)
ST_INTERSECTION
function.stIntersection(T arg1,
Field<T> arg2)
ST_INTERSECTION
function.stIntersection(T arg1,
T arg2)
ST_INTERSECTION
function.stIntersects(Field<T> arg1,
Field<T> arg2)
ST_INTERSECTS
function.stIntersects(Field<T> arg1,
T arg2)
ST_INTERSECTS
function.stIntersects(T arg1,
Field<T> arg2)
ST_INTERSECTS
function.stIntersects(T arg1,
T arg2)
ST_INTERSECTS
function.static @NotNull Condition
stIsClosed(Field<? extends Spatial> value)
ST_ISCLOSED
function.static @NotNull Condition
stIsClosed(Spatial value)
ST_ISCLOSED
function.static @NotNull Condition
ST_ISEMPTY
function.static @NotNull Condition
ST_ISEMPTY
function.ST_LENGTH
function.ST_LENGTH
function.stNumGeometries(Field<? extends Spatial> value)
ST_NUMGEOMETRIES
function.stNumGeometries(Spatial value)
ST_NUMGEOMETRIES
function.stNumInteriorRings(Field<Geometry> value)
ST_NUMINTERIORRING
function.stNumInteriorRings(Geometry value)
ST_NUMINTERIORRING
function.stNumPoints(Field<? extends Spatial> value)
ST_NUMPOINTS
function.stNumPoints(Spatial value)
ST_NUMPOINTS
function.stOverlaps(Field<T> arg1,
Field<T> arg2)
ST_OVERLAPS
function.stOverlaps(Field<T> arg1,
T arg2)
ST_OVERLAPS
function.stOverlaps(T arg1,
Field<T> arg2)
ST_OVERLAPS
function.stOverlaps(T arg1,
T arg2)
ST_OVERLAPS
function.ST_POINTN
function.ST_POINTN
function.stPointN(T value,
int position)
ST_POINTN
function.ST_POINTN
function.ST_SRID
function.ST_SRID
function.stStartPoint(Field<T> value)
ST_STARTPOINT
function.stStartPoint(T value)
ST_STARTPOINT
function.ST_TOUCHES
function.ST_TOUCHES
function.ST_TOUCHES
function.stTouches(T arg1,
T arg2)
ST_TOUCHES
function.ST_UNION
function.ST_UNION
function.ST_UNION
function.stUnion(T arg1,
T arg2)
ST_UNION
function.ST_WITHIN
function.ST_WITHIN
function.ST_WITHIN
function.stWithin(T arg1,
T arg2)
ST_WITHIN
function.ST_X
function.ST_X
function.ST_Y
function.ST_Y
function.ST_Z
function.ST_Z
function.SUBSTRING
function.SUBSTRING
function.SUBSTRING
function.SUBSTRING
function.SUBSTRING
function.substring(Field<String> string,
Field<? extends Number> startingPosition,
Field<? extends Number> length)
SUBSTRING
function.substringIndex(Field<String> string,
String delimiter,
int n)
SUBSTRING_INDEX
function.SUBSTRING_INDEX
function.substringIndex(Field<String> string,
Field<String> delimiter,
int n)
SUBSTRING_INDEX
function.SUBSTRING_INDEX
function.static @NotNull AggregateFunction<BigDecimal>
SUM
function.static @NotNull AggregateFunction<BigDecimal>
sumDistinct(Field<? extends Number> field)
SUM_DISTINCT
function.sysConnectByPath(Field<?> field,
String separator)
SYS_CONNECT_BY_PATH
function.static @NotNull Name
systemName(String unqualifiedName)
static @NotNull Name
systemName(String... qualifiedName)
static @NotNull Name
systemName(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.TRIM
function.TRIM
function.TRIM
function.TRIM
function.TRIM
function.TRIM
function.static @NotNull True
Condition
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 <R extends Record>
TruncateIdentityStep<R>
TRUNCATE
statement.static TruncateIdentityStep<Record>
truncateTable(String table)
TRUNCATE TABLE
statement.static TruncateIdentityStep<Record>
truncateTable(Name table)
TRUNCATE TABLE
statement.static <R extends Record>
TruncateIdentityStep<R>
truncateTable(Table<R> table)
TRUNCATE TABLE
statement.two()
2
literal.static @NotNull ConstraintEnforcementStep
UNIQUE
constraint.static @NotNull ConstraintEnforcementStep
unique(Collection<? extends Field<?>> fields)
UNIQUE
constraint.static @NotNull ConstraintEnforcementStep
UNIQUE
constraint.static @NotNull ConstraintEnforcementStep
UNIQUE
constraint.static @NotNull Condition
UNIQUE
function.static @NotNull Table<?>
static @NotNull Table<?>
unnest(Collection<?> list)
static @NotNull Table<?>
unnest(ArrayRecord<?> array)
static @NotNull Table<?>
static @NotNull Name
unquotedName(String unqualifiedName)
static @NotNull Name
unquotedName(String... qualifiedName)
static @NotNull Name
unquotedName(Collection<String> qualifiedName)
static <R extends Record>
@NotNull UpdateSetFirstStep<R>
static @NotNull Condition
updating()
UPDATING
function.UPPER
function.UPPER
function.static @NotNull User
static @NotNull User
static @NotNull DSLContext
using(io.r2dbc.spi.Connection connection)
static @NotNull DSLContext
using(io.r2dbc.spi.ConnectionFactory connectionFactory)
static @NotNull DSLContext
using(io.r2dbc.spi.ConnectionFactory connectionFactory,
SQLDialect dialect)
static @NotNull DSLContext
using(io.r2dbc.spi.ConnectionFactory connectionFactory,
SQLDialect dialect,
Settings settings)
static @NotNull DSLContext
using(io.r2dbc.spi.Connection connection,
SQLDialect dialect)
static @NotNull DSLContext
using(io.r2dbc.spi.Connection connection,
SQLDialect dialect,
Settings settings)
static @NotNull CloseableDSLContext
static @NotNull CloseableDSLContext
static @NotNull CloseableDSLContext
using(String url,
Properties properties)
static @NotNull DSLContext
using(Connection connection)
static @NotNull DSLContext
using(Connection connection,
Settings settings)
static @NotNull DSLContext
using(Connection connection,
SQLDialect dialect)
static @NotNull DSLContext
using(Connection connection,
SQLDialect dialect,
Settings settings)
static @NotNull DSLContext
using(DataSource datasource,
SQLDialect dialect)
static @NotNull DSLContext
using(DataSource datasource,
SQLDialect dialect,
Settings settings)
static @NotNull DSLContext
using(Configuration configuration)
static @NotNull DSLContext
using(ConnectionProvider connectionProvider,
SQLDialect dialect)
static @NotNull DSLContext
using(ConnectionProvider connectionProvider,
SQLDialect dialect,
Settings settings)
static @NotNull DSLContext
using(SQLDialect dialect)
static @NotNull DSLContext
using(SQLDialect dialect,
Settings settings)
uuid()
UUID
function.val(boolean value)
val(byte value)
static @NotNull Param<byte[]>
val(byte[] value)
val(double value)
val(float value)
val(int value)
val(long value)
val(short value)
static <T> @NotNull Param<T>
static <T> @NotNull Param<T>
static <T> @NotNull Param<T>
static @NotNull Param<BigDecimal>
val(BigDecimal value)
static @NotNull Param<BigInteger>
val(BigInteger value)
static @NotNull Param<LocalDateTime>
val(LocalDateTime value)
static @NotNull Param<OffsetDateTime>
val(OffsetDateTime value)
static @NotNull Param<OffsetTime>
val(OffsetTime value)
static <T> @NotNull Param<T>
val(T value)
value(boolean value)
val(boolean)
to be used in Scala and Groovy, where
val
is a reserved keyword.value(byte value)
val(byte)
to be used in Scala and Groovy, where
val
is a reserved keyword.static @NotNull Param<byte[]>
value(byte[] value)
val(byte[])
to be used in Scala and Groovy, where
val
is a reserved keyword.value(double value)
val(double)
to be used in Scala and Groovy, where
val
is a reserved keyword.value(float value)
val(float)
to be used in Scala and Groovy, where
val
is a reserved keyword.value(int value)
val(int)
to be used in Scala and Groovy, where
val
is a reserved keyword.value(long value)
val(long)
to be used in Scala and Groovy, where
val
is a reserved keyword.value(short value)
val(short)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Boolean)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Byte)
to be used in Scala and Groovy, where
val
is a reserved keyword.static <T> @NotNull Field<T>
VALUE
pseudo field for usage with
DOMAIN
specifications.val(Double)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Float)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Integer)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Long)
to be used in Scala and Groovy, where
val
is a reserved keyword.static <T> @NotNull Param<T>
val(Object, Class)
to be used in Scala and Groovy,
where val
is a reserved keyword.static <T> @NotNull Param<T>
val(Object, DataType)
to be used in Scala and Groovy, where
val
is a reserved keyword.static <T> @NotNull Param<T>
val(Object, Field)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Short)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(String)
to be used in Scala and Groovy, where
val
is a reserved keyword.static @NotNull Param<BigDecimal>
value(BigDecimal value)
val(BigDecimal)
to be used in Scala and Groovy, where
val
is a reserved keyword.static @NotNull Param<BigInteger>
value(BigInteger value)
val(BigInteger)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Date)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Time)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Timestamp)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Instant)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(LocalDate)
to be used in Scala and Groovy, where
val
is a reserved keyword.static @NotNull Param<LocalDateTime>
value(LocalDateTime value)
val(LocalDateTime)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(LocalTime)
to be used in Scala and Groovy, where
val
is a reserved keyword.static @NotNull Param<OffsetDateTime>
value(OffsetDateTime value)
val(OffsetDateTime)
to be used in Scala and Groovy, where
val
is a reserved keyword.static @NotNull Param<OffsetTime>
value(OffsetTime value)
val(OffsetTime)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(UUID)
to be used in Scala and Groovy, where
val
is a reserved keyword.static <T> @NotNull Field<T>
VALUE
pseudo field for usage with
DOMAIN
specifications.val(Geography)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Geometry)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(JSON)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(JSONB)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(UByte)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(UInteger)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(ULong)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(UShort)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(XML)
to be used in Scala and Groovy, where
val
is a reserved keyword.static <T> @NotNull Param<T>
value(T value)
val(Object)
to be used in Scala and Groovy, where
val
is a reserved keyword.VALUES()
expression of degree 1
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10>
@NotNull Table<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>
VALUES()
expression of degree 10
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11>
@NotNull Table<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>
VALUES()
expression of degree 11
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12>
@NotNull Table<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>
VALUES()
expression of degree 12
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13>
@NotNull Table<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>
VALUES()
expression of degree 13
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14>
@NotNull Table<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>
VALUES()
expression of degree 14
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15>
@NotNull Table<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>
VALUES()
expression of degree 15
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16>
@NotNull Table<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>
VALUES()
expression of degree 16
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17>
@NotNull Table<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>
VALUES()
expression of degree 17
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18>
@NotNull Table<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>
VALUES()
expression of degree 18
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19>
@NotNull Table<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>
VALUES()
expression of degree 19
.VALUES()
expression of degree 2
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20>
@NotNull Table<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>
VALUES()
expression of degree 20
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21>
@NotNull Table<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>
VALUES()
expression of degree 21
.static <T1,
T2,
T3,
T4,
T5,
T6,
T7,
T8,
T9,
T10,
T11,
T12,
T13,
T14,
T15,
T16,
T17,
T18,
T19,
T20,
T21,
T22>
@NotNull Table<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>
values(Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>... rows)
VALUES()
expression of degree 22
.VALUES()
expression of degree 3
.VALUES()
expression of degree 4
.VALUES()
expression of degree 5
.VALUES()
expression of degree 6
.VALUES()
expression of degree 7
.VALUES()
expression of degree 8
.VALUES()
expression of degree 9
.VALUES()
expression of arbitrary degree.static <T> @NotNull Variable<T>
static <T> @NotNull Variable<T>
static <T> @NotNull Variable<T>
var(Name, DataType)
to be used in Scala and
Groovy, where var
is a reserved keyword.static <T> @NotNull Variable<T>
var(Name, DataType)
to be used in Scala and
Groovy, where var
is a reserved keyword.static @NotNull AggregateFunction<BigDecimal>
VAR_POP
function.static @NotNull AggregateFunction<BigDecimal>
VAR_SAMP
function.static <T> @NotNull CaseConditionStep<T>
Case
statement.static <T> @NotNull CaseConditionStep<T>
Case
statement.static <T> @NotNull CaseConditionStep<T>
Case
statement.static <T> @NotNull CaseConditionStep<T>
Case
statement.static <T> @NotNull CaseConditionStep<T>
Case
statement.static <T> @NotNull CaseConditionStep<T>
Case
statement.static @NotNull LoopStep
WHILE
loop for use in procedural code.WIDTH_BUCKET
function.widthBucket(Field<T> field,
T low,
T high,
int buckets)
WIDTH_BUCKET
function.static @NotNull WithAsStep
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep1
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep2
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep3
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep4
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep5
with(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
CommonTableExpression
s.static @NotNull WithAsStep6
with(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
CommonTableExpression
s.static @NotNull WithAsStep7
with(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
CommonTableExpression
s.static @NotNull WithAsStep8
with(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
CommonTableExpression
s.static @NotNull WithAsStep9
with(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
CommonTableExpression
s.static @NotNull WithAsStep10
with(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
CommonTableExpression
s.static @NotNull WithAsStep11
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep12
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep13
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep14
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep15
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep16
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep17
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep18
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17,
String fieldAlias18)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep19
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17,
String fieldAlias18,
String fieldAlias19)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep20
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17,
String fieldAlias18,
String fieldAlias19,
String fieldAlias20)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep21
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17,
String fieldAlias18,
String fieldAlias19,
String fieldAlias20,
String fieldAlias21)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep22
with(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17,
String fieldAlias18,
String fieldAlias19,
String fieldAlias20,
String fieldAlias21,
String fieldAlias22)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
with(String alias,
Collection<String> fieldAliases)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
static @NotNull WithStep
with(Collection<? extends CommonTableExpression<?>> tables)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithStep
with(CommonTableExpression<?>... tables)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
with(Name alias,
Collection<? extends Name> fieldAliases)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep1
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep2
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep3
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep4
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep5
with(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
CommonTableExpression
s.static @NotNull WithAsStep6
with(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
CommonTableExpression
s.static @NotNull WithAsStep7
with(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
CommonTableExpression
s.static @NotNull WithAsStep8
with(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
CommonTableExpression
s.static @NotNull WithAsStep9
with(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
CommonTableExpression
s.static @NotNull WithAsStep10
with(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
CommonTableExpression
s.static @NotNull WithAsStep11
with(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
CommonTableExpression
s.static @NotNull WithAsStep12
with(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
CommonTableExpression
s.static @NotNull WithAsStep13
with(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
CommonTableExpression
s.static @NotNull WithAsStep14
with(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
CommonTableExpression
s.static @NotNull WithAsStep15
with(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
CommonTableExpression
s.static @NotNull WithAsStep16
with(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
CommonTableExpression
s.static @NotNull WithAsStep17
with(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
CommonTableExpression
s.static @NotNull WithAsStep18
with(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
CommonTableExpression
s.static @NotNull WithAsStep19
with(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
CommonTableExpression
s.static @NotNull WithAsStep20
with(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
CommonTableExpression
s.static @NotNull WithAsStep21
with(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
CommonTableExpression
s.static @NotNull WithAsStep22
with(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
CommonTableExpression
s.static @NotNull WithAsStep
withRecursive(String alias)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep1
withRecursive(String alias,
String fieldAlias1)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
withRecursive(String alias,
String... fieldAliases)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep2
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep3
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep4
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep5
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep6
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep7
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep8
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep9
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep10
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep11
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep12
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep13
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep14
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep15
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep16
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep17
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep18
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17,
String fieldAlias18)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep19
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17,
String fieldAlias18,
String fieldAlias19)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep20
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17,
String fieldAlias18,
String fieldAlias19,
String fieldAlias20)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep21
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17,
String fieldAlias18,
String fieldAlias19,
String fieldAlias20,
String fieldAlias21)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep22
withRecursive(String alias,
String fieldAlias1,
String fieldAlias2,
String fieldAlias3,
String fieldAlias4,
String fieldAlias5,
String fieldAlias6,
String fieldAlias7,
String fieldAlias8,
String fieldAlias9,
String fieldAlias10,
String fieldAlias11,
String fieldAlias12,
String fieldAlias13,
String fieldAlias14,
String fieldAlias15,
String fieldAlias16,
String fieldAlias17,
String fieldAlias18,
String fieldAlias19,
String fieldAlias20,
String fieldAlias21,
String fieldAlias22)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
withRecursive(String alias,
Collection<String> fieldAliases)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
withRecursive(String alias,
Function<? super Field<?>,? extends String> fieldNameFunction)
static @NotNull WithStep
withRecursive(Collection<? extends CommonTableExpression<?>> tables)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithStep
withRecursive(CommonTableExpression<?>... tables)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
withRecursive(Name alias)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
withRecursive(Name alias,
Collection<? extends Name> fieldAliases)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep1
withRecursive(Name alias,
Name fieldAlias1)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep
withRecursive(Name alias,
Name... fieldAliases)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep2
withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep3
withRecursive(Name alias,
Name fieldAlias1,
Name fieldAlias2,
Name fieldAlias3)
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep4
WITH
clause to supply subsequent
SELECT
, UPDATE
, INSERT
,
DELETE
, and MERGE
statements with
CommonTableExpression
s.static @NotNull WithAsStep5
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep6
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep7
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep8
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep9
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep10
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep11
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep12
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep13
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep14
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep15
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep16
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep17
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep18
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep19
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep20
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep21
withRecursive(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
CommonTableExpression
s.static @NotNull WithAsStep22
withRecursive(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
CommonTableExpression
s.static @NotNull XMLAggOrderByStep<XML>
static @NotNull XMLAttributes
xmlattributes(Collection<? extends Field<?>> attributes)
static @NotNull XMLAttributes
xmlattributes(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 XMLExistsPassingStep
static @NotNull XMLExistsPassingStep
xmlforest(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 XMLQueryPassingStep
static @NotNull XMLQueryPassingStep
static <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 XMLTablePassingStep
static @NotNull XMLTablePassingStep
zero()
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
Reusable CommonTableExpression
types can be constructed through
name(String...)
Name.fields(String...)
DerivedColumnList#as(Select)
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
Reusable CommonTableExpression
types can be constructed through
name(String...)
Name.fields(String...)
DerivedColumnList#as(Select)
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
Reusable CommonTableExpression
types can be constructed through
name(String...)
Name.fields(String...)
DerivedColumnList#as(Select)
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
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
CommonTableExpression
s.
Reusable CommonTableExpression
types can be constructed through
name(String...)
Name.fields(String...)
DerivedColumnList#as(Select)
The RECURSIVE
keyword may be optional or unsupported in some
databases, in case of which it will not be rendered. For optimal database
interoperability and readability, however, it is suggested that you use
with(CommonTableExpression...)
for strictly non-recursive CTE
and withRecursive(CommonTableExpression...)
for strictly
recursive CTE.
Note that the SQLDialect.H2
database only supports single-table,
RECURSIVE
common table expression lists.
This will project the known columns from the argument table querying
Fields.fields()
. If no known columns are available (e.g. because
the table has been created using table(String)
), then
SELECT *
is projected.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
SELECT table.col1, table.col2 FROM table
*
.
Without knowing any columns from the argument table (see
selectFrom(TableLike)
), this will project SELECT *
.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
SELECT * FROM table
*
.
Without knowing any columns from the argument table (see
selectFrom(TableLike)
), this will project SELECT *
.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
SELECT * FROM table
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
*
.
Without knowing any columns from the argument table (see
selectFrom(TableLike)
), this will project SELECT *
.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
SELECT * FROM table
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
*
.
Without knowing any columns from the argument table (see
selectFrom(TableLike)
), this will project SELECT *
.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
SELECT * FROM table
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
*
.
Without knowing any columns from the argument table (see
selectFrom(TableLike)
), this will project SELECT *
.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
SELECT * FROM table
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(fields)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
Note that passing an empty collection conveniently produces
SELECT *
semantics, i.e. it:
SELECT tab1.col1, tab1.col2, …, tabN.colN
if
all columns are knownSELECT *
if not all columns are known, e.g. when
using plain SQL
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
Note that passing an empty collection conveniently produces
SELECT *
semantics, i.e. it:
SELECT tab1.col1, tab1.col2, …, tabN.colN
if
all columns are knownSELECT *
if not all columns are known, e.g. when
using plain SQL
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Field.in(Select)
, Field.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row2.in(Select)
, Row2.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row3.in(Select)
, Row3.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row4.in(Select)
, Row4.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, field4)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row5.in(Select)
, Row5.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, field4, field5)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row6.in(Select)
, Row6.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field5, field6)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row7.in(Select)
, Row7.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field6, field7)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row8.in(Select)
, Row8.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field7, field8)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row9.in(Select)
, Row9.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field8, field9)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row10.in(Select)
, Row10.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field9, field10)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row11.in(Select)
, Row11.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field10, field11)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row12.in(Select)
, Row12.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field11, field12)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row13.in(Select)
, Row13.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field12, field13)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row14.in(Select)
, Row14.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field13, field14)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row15.in(Select)
, Row15.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field14, field15)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row16.in(Select)
, Row16.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field15, field16)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row17.in(Select)
, Row17.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field16, field17)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row18.in(Select)
, Row18.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field17, field18)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row19.in(Select)
, Row19.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field18, field19)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row20.in(Select)
, Row20.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field19, field20)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row21.in(Select)
, Row21.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field20, field21)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as select(SelectFieldOrAsterisk...)
, except that it declares
additional record-level typesafety, which is needed by
Row22.in(Select)
, Row22.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
select(field1, field2, field3, .., field21, field22)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(fields)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
Note that passing an empty collection conveniently produces
SELECT DISTINCT *
semantics, i.e. it:
SELECT DISTINCT tab1.col1, tab1.col2, …, tabN.colN
if
all columns are knownSELECT DISTINCT *
if not all columns are known, e.g. when
using plain SQL
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
Note that passing an empty collection conveniently produces
SELECT DISTINCT *
semantics, i.e. it:
SELECT DISTINCT tab1.col1, tab1.col2, …, tabN.colN
if
all columns are knownSELECT DISTINCT *
if not all columns are known, e.g. when
using plain SQL
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Field.in(Select)
, Field.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row2.in(Select)
, Row2.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row3.in(Select)
, Row3.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row4.in(Select)
, Row4.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, field4)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row5.in(Select)
, Row5.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, field4, field5)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row6.in(Select)
, Row6.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field5, field6)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row7.in(Select)
, Row7.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field6, field7)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row8.in(Select)
, Row8.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field7, field8)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row9.in(Select)
, Row9.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field8, field9)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row10.in(Select)
, Row10.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field9, field10)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row11.in(Select)
, Row11.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field10, field11)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row12.in(Select)
, Row12.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field11, field12)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row13.in(Select)
, Row13.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field12, field13)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row14.in(Select)
, Row14.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field13, field14)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row15.in(Select)
, Row15.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field14, field15)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row16.in(Select)
, Row16.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field15, field16)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row17.in(Select)
, Row17.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field16, field17)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row18.in(Select)
, Row18.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field17, field18)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row19.in(Select)
, Row19.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field18, field19)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row20.in(Select)
, Row20.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field19, field20)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row21.in(Select)
, Row21.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field20, field21)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
This is the same as selectDistinct(SelectFieldOrAsterisk...)
, except that it
declares additional record-level typesafety, which is needed by
Row22.in(Select)
, Row22.equal(Select)
and other predicate
building methods taking subselect arguments.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectDistinct(field1, field2, field3, .., field21, field22)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
0
literal.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectZero()
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
1
literal.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectOne()
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
COUNT(*)
.
Unlike Select
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
SELECT
statement. You can use this statement in two ways:
Attachable.attach(org.jooq.Configuration)
Example:
import static org.jooq.impl.DSL.*;
// [...]
selectCount()
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
This type of insert may feel more convenient to some users, as it uses
the UPDATE
statement's SET a = b
syntax.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table)
.set(field1, value1)
.set(field2, value2)
.newRecord()
.set(field1, value3)
.set(field2, value4)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1)
.values(field1)
.values(field1)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2)
.values(field1, field2)
.values(field1, field2)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3)
.values(field1, field2, field3)
.values(field1, field2, field3)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, field4)
.values(field1, field2, field3, field4)
.values(field1, field2, field3, field4)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, field4, field5)
.values(field1, field2, field3, field4, field5)
.values(field1, field2, field3, field4, field5)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field5, field6)
.values(valueA1, valueA2, valueA3, .., valueA5, valueA6)
.values(valueB1, valueB2, valueB3, .., valueB5, valueB6)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field6, field7)
.values(valueA1, valueA2, valueA3, .., valueA6, valueA7)
.values(valueB1, valueB2, valueB3, .., valueB6, valueB7)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field7, field8)
.values(valueA1, valueA2, valueA3, .., valueA7, valueA8)
.values(valueB1, valueB2, valueB3, .., valueB7, valueB8)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field8, field9)
.values(valueA1, valueA2, valueA3, .., valueA8, valueA9)
.values(valueB1, valueB2, valueB3, .., valueB8, valueB9)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field9, field10)
.values(valueA1, valueA2, valueA3, .., valueA9, valueA10)
.values(valueB1, valueB2, valueB3, .., valueB9, valueB10)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field10, field11)
.values(valueA1, valueA2, valueA3, .., valueA10, valueA11)
.values(valueB1, valueB2, valueB3, .., valueB10, valueB11)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field11, field12)
.values(valueA1, valueA2, valueA3, .., valueA11, valueA12)
.values(valueB1, valueB2, valueB3, .., valueB11, valueB12)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field12, field13)
.values(valueA1, valueA2, valueA3, .., valueA12, valueA13)
.values(valueB1, valueB2, valueB3, .., valueB12, valueB13)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field13, field14)
.values(valueA1, valueA2, valueA3, .., valueA13, valueA14)
.values(valueB1, valueB2, valueB3, .., valueB13, valueB14)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field14, field15)
.values(valueA1, valueA2, valueA3, .., valueA14, valueA15)
.values(valueB1, valueB2, valueB3, .., valueB14, valueB15)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field15, field16)
.values(valueA1, valueA2, valueA3, .., valueA15, valueA16)
.values(valueB1, valueB2, valueB3, .., valueB15, valueB16)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field16, field17)
.values(valueA1, valueA2, valueA3, .., valueA16, valueA17)
.values(valueB1, valueB2, valueB3, .., valueB16, valueB17)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field17, field18)
.values(valueA1, valueA2, valueA3, .., valueA17, valueA18)
.values(valueB1, valueB2, valueB3, .., valueB17, valueB18)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field18, field19)
.values(valueA1, valueA2, valueA3, .., valueA18, valueA19)
.values(valueB1, valueB2, valueB3, .., valueB18, valueB19)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field19, field20)
.values(valueA1, valueA2, valueA3, .., valueA19, valueA20)
.values(valueB1, valueB2, valueB3, .., valueB19, valueB20)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field20, field21)
.values(valueA1, valueA2, valueA3, .., valueA20, valueA21)
.values(valueB1, valueB2, valueB3, .., valueB20, valueB21)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2, field3, .., field21, field22)
.values(valueA1, valueA2, valueA3, .., valueA21, valueA22)
.values(valueB1, valueB2, valueB3, .., valueB21, valueB22)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2)
.values(valueA1, valueA2)
.values(valueB1, valueB2)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Insert
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
INSERT
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
insertInto(table, field1, field2)
.values(valueA1, valueA2)
.values(valueB1, valueB2)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
Unlike Update
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
UPDATE
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
update(table)
.set(field1, value1)
.set(field2, value2)
.where(field1.greaterThan(100))
Note that some databases support table expressions more complex than simple table references. In MySQL, for instance, you can write
update(t1.join(t2).on(t1.id.eq(t2.id)))
.set(t1.value, value1)
.set(t2.value, value2)
.where(t1.id.eq(10))
Unlike Merge
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
MERGE
statement.
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
dialect | support type | documentation |
---|---|---|
DB2 | SQL:2008 standard and major enhancements | http://publib.boulder.ibm.com/infocenter/db2luw/v9/index.jsp?topic=/com. ibm.db2.udb.admin.doc/doc/r0010873.htm |
HSQLDB | SQL:2008 standard | http://hsqldb.org/doc/2.0/guide/dataaccess-chapt.html#N129BA |
Oracle | SQL:2008 standard and minor enhancements | http://download.oracle.com/docs/cd/B28359_01/server.111/b28286/ statements_9016.htm |
SQL Server | Similar to SQL:2008 standard with some major enhancements | http://msdn.microsoft.com/de-de/library/bb510625.aspx |
Sybase | Similar to SQL:2008 standard with some major enhancements | http://dcx.sybase.com/1100/en/dbreference_en11/merge-statement.html |
Example:
import static org.jooq.impl.DSL.*;
// [...]
mergeInto(table)
.using(select)
.on(condition)
.whenMatchedThenUpdate()
.set(field1, value1)
.set(field2, value2)
.whenNotMatchedThenInsert(field1, field2)
.values(value1, value2)
Note: Using this method, you can also create an H2-specific MERGE
statement without field specification. See also
mergeInto(Table, Field...)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
mergeInto(Table)
Unlike Merge
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
MERGE
statement.
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
H2 | H2 natively supports this special syntax | https://www.h2database.com/html/commands.html#merge_into |
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can emulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
mergeInto(Table)
Unlike Merge
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
MERGE
statement.
Unlike Delete
factory methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
DELETE
statement.
Example:
import static org.jooq.impl.DSL.*;
// [...]
deleteFrom(table)
.where(field1.greaterThan(100))
Some but not all databases support aliased tables in delete statements.
This is an alias for deleteFrom(Table)
CONSTRAINT
specification.CONSTRAINT
specification.CONSTRAINT
specification.PRIMARY KEY
constraint.PRIMARY KEY
constraint.PRIMARY KEY
constraint.PRIMARY KEY
constraint.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.FOREIGN KEY
clause to the CONSTRAINT
.UNIQUE
constraint.UNIQUE
constraint.UNIQUE
constraint.UNIQUE
constraint.CHECK
constraint.ALTER DATABASE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DATABASE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DATABASE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DATABASE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DATABASE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DATABASE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER DOMAIN IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER INDEX IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SCHEMA IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER SEQUENCE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER TYPE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER TYPE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
ALTER 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.
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 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 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 SCHEMA
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SCHEMA
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SCHEMA
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SCHEMA IF NOT EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SCHEMA IF NOT EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SCHEMA IF NOT EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE IF NOT EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE IF NOT EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
CREATE SEQUENCE IF NOT EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DATABASE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP DOMAIN IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP FUNCTION
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP FUNCTION
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP FUNCTION IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP FUNCTION IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP INDEX IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP PROCEDURE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP PROCEDURE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP PROCEDURE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP PROCEDURE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SCHEMA IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP SEQUENCE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TABLE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TEMPORARY TABLE IF EXISTS
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TRIGGER
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TRIGGER
statement.
Unlike statement construction methods in the DSLContext
API, this
creates an unattached, and thus not directly renderable or executable
statement. It can be used as a subquery or nested in procedural logic.
DROP TRIGGER 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 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.
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 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 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.
CREATE VIEW
statement.CREATE VIEW
statement.CREATE VIEW
statement.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.CREATE OR REPLACE VIEW
statement.CREATE OR REPLACE VIEW
statement.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.CREATE VIEW IF NOT EXISTS
statement.CREATE VIEW IF NOT EXISTS
statement.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.
CREATE TYPE
statement.CREATE TYPE
statement.DROP TYPE
statement.DROP TYPE
statement.DROP TYPE
statement.DROP TYPE
statement.DROP TYPE
statement.DROP TYPE
statement.DROP TYPE
statement.DROP TYPE
statement.DROP TYPE
statement.DROP TYPE
statement.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.Field
that behaves like no field being present.
When creating dynamic SQL queries using expressions, it is often useful
to be able to decide dynamically whether a clause is being added to a
query or not. In case that clause accepts fields, the noField()
can be used to avoid creating a clause, which is useful for the following
Select
clauses, for example:
SelectGroupByStep.groupBy(GroupField...)
SelectOrderByStep.orderBy(OrderField...)
SelectLimitStep.limit(Field)
SelectOffsetStep.offset(Field)
Record
type, the
noField()
simply projects NULL
and cannot be used
to avoid the clause.
NOTE [#16918] that this Field
is meant to be used with the
DSL
API only, not with the QOM
API, which cannot offer
any no-op operations. The behaviour when used with the QOM
API is
undefined.
Field
that behaves like no field being present.
When creating dynamic SQL queries using expressions, it is often useful
to be able to decide dynamically whether a clause is being added to a
query or not. In case that clause accepts fields, the noField()
can be used to avoid creating a clause, which is useful for the following
Select
clauses, for example:
SelectGroupByStep.groupBy(GroupField...)
SelectOrderByStep.orderBy(OrderField...)
SelectLimitStep.limit(Field)
SelectOffsetStep.offset(Field)
Record
type, the
noField()
simply projects NULL
and cannot be used
to avoid the clause.
NOTE [#15286]: It is strongly recommended to pass only Class
references
of types supported by jOOQ internally, i.e. types from
SQLDataType
. If you're using any custom data types by means of a
Converter
or Binding
, it's better to pass that converted
DataType
reference explicitly to noField(DataType)
.
NOTE [#16918] that this Field
is meant to be used with the
DSL
API only, not with the QOM
API, which cannot offer
any no-op operations. The behaviour when used with the QOM
API is
undefined.
type
- A class to derive the Typed.getDataType()
from.Field
that behaves like no field being present.
When creating dynamic SQL queries using expressions, it is often useful
to be able to decide dynamically whether a clause is being added to a
query or not. In case that clause accepts fields, the noField()
can be used to avoid creating a clause, which is useful for the following
Select
clauses, for example:
SelectGroupByStep.groupBy(GroupField...)
SelectOrderByStep.orderBy(OrderField...)
SelectLimitStep.limit(Field)
SelectOffsetStep.offset(Field)
Record
type, the
noField()
simply projects NULL
and cannot be used
to avoid the clause.
NOTE [#16918] that this Field
is meant to be used with the
DSL
API only, not with the QOM
API, which cannot offer
any no-op operations. The behaviour when used with the QOM
API is
undefined.
type
- A type to derive the Typed.getDataType()
from.Field
that behaves like no field being present.
When creating dynamic SQL queries using expressions, it is often useful
to be able to decide dynamically whether a clause is being added to a
query or not. In case that clause accepts fields, the noField()
can be used to avoid creating a clause, which is useful for the following
Select
clauses, for example:
SelectGroupByStep.groupBy(GroupField...)
SelectOrderByStep.orderBy(OrderField...)
SelectLimitStep.limit(Field)
SelectOffsetStep.offset(Field)
Record
type, the
noField()
simply projects NULL
and cannot be used
to avoid the clause.
NOTE [#16918] that this Field
is meant to be used with the
DSL
API only, not with the QOM
API, which cannot offer
any no-op operations. The behaviour when used with the QOM
API is
undefined.
type
- A field to derive the Typed.getDataType()
from.This constructs a catalog reference given the catalog's qualified name.
Example:
// This catalog...
catalog(name("MY_CATALOG"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_CATALOG]
This constructs a catalog reference given the catalog's qualified name.
Example:
// This catalog...
catalog(name("MY_CATALOG"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_CATALOG]
This constructs a schema reference given the schema's qualified name.
Example:
// This schema...
schema(name("MY_CATALOG", "MY_SCHEMA"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_CATALOG].[MY_SCHEMA]
This constructs a schema reference given the schema's qualified name.
Example:
// This schema...
schema(name("MY_CATALOG", "MY_SCHEMA"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_CATALOG].[MY_SCHEMA]
This constructs a sequence reference given the sequence's qualified name.
Example:
// This sequence...
sequence(name("MY_SCHEMA", "MY_SEQUENCE"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_SEQUENCE]
This constructs a sequence reference given the sequence's qualified name.
Example:
// This sequence...
sequence(name("MY_SCHEMA", "MY_SEQUENCE"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_SEQUENCE]
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType
. If you're using any custom data types by means of a
Converter
or Binding
, it's better to pass that converted
DataType
reference explicitly to
sequence(Name, DataType)
.
name
- The sequence nametype
- The sequence type (a type that is supported by
SQLDataType
)This constructs a sequence reference given the sequence's qualified name.
Example:
// This sequence...
sequence(name("MY_SCHEMA", "MY_SEQUENCE"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_SEQUENCE]
This constructs a table reference given the table's qualified name. jOOQ
Example:
// This table...
tableByName("MY_SCHEMA", "MY_TABLE");
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE]
The returned table does not know its field references, i.e.
Fields.fields()
returns an empty array.
This constructs a table reference given the table's qualified name. jOOQ
Example:
// This table...
tableByName("MY_SCHEMA", "MY_TABLE");
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE]
The returned table does not know its field references, i.e.
Fields.fields()
returns an empty array.
This constructs a field reference given the field's qualified name. jOOQ
Example:
// This field...
field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE].[MY_FIELD]
Another example:
create.select(field("length({1})", Integer.class, field(name("TITLE"))))
.from(table(name("T_BOOK")))
.fetch();
// ... will execute this SQL on SQL Server:
select length([TITLE]) from [T_BOOK]
NOTE: A lot of things work less well in jOOQ if no
DataType
information is attached to a Field
expression,
including:
NULL
values.field(Name, DataType)
, instead,
or even better, use code generation where possible: https://blog.jooq.org/why-you-should-use-jooq-with-code-generation/,
in case of which DataType
information is attached to all
Field
expressions automatically.This constructs a field reference given the field's qualified name. jOOQ
Example:
// This field...
field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE].[MY_FIELD]
Another example:
create.select(field("length({1})", Integer.class, field(name("TITLE"))))
.from(table(name("T_BOOK")))
.fetch();
// ... will execute this SQL on SQL Server:
select length([TITLE]) from [T_BOOK]
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType
. If you're using any custom data types by means of a
Converter
or Binding
, it's better to pass that converted
DataType
reference explicitly to
field(Name, DataType)
.
name
- The field nametype
- The field type (a type that is supported by
SQLDataType
)This constructs a field reference given the field's qualified name. jOOQ
Example:
// This field...
field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE].[MY_FIELD]
Another example:
create.select(field("length({1})", Integer.class, field(name("TITLE"))))
.from(table(name("T_BOOK")))
.fetch();
// ... will execute this SQL on SQL Server:
select length([TITLE]) from [T_BOOK]
This constructs a field reference given the field's qualified name. jOOQ
Example:
// This field...
field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));
// ... will render this SQL by default, using the SQL Server dialect
[MY_SCHEMA].[MY_TABLE].[MY_FIELD]
Another example:
create.select(field("length({1})", Integer.class, field(name("TITLE"))))
.from(table(name("T_BOOK")))
.fetch();
// ... will execute this SQL on SQL Server:
select length([TITLE]) from [T_BOOK]
Period
reference.Period
reference.
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType
. If you're using any custom data types by means of a
Converter
or Binding
, it's better to pass that converted
DataType
reference explicitly to
period(Name, DataType)
.
name
- The period nametype
- The period type (a type that is supported by
SQLDataType
)Period
reference.SYSTEM_TIME
Period
reference.SYSTEM_TIME
Period
reference.
NOTE [#15286]: It is strongly recommended to pass only Class
references
of types supported by jOOQ internally, i.e. types from
SQLDataType
. If you're using any custom data types by means of a
Converter
or Binding
, it's better to pass that converted
DataType
reference explicitly to systemTime(DataType)
.
SYSTEM_TIME
Period
reference.IN
parameter.IN
parameter.IN OUT
parameter.IN OUT
parameter.OUT
parameter.OUT
parameter.
A plain SQL QueryPart
is a QueryPart
that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQL
A plain SQL QueryPart
is a QueryPart
that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQL
A plain SQL QueryPart
is a QueryPart
that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQL
A plain SQL QueryPart
is a QueryPart
that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQLBEGIN … END;
, unless explicitly needed.BEGIN … END;
, unless explicitly needed.var(Name, DataType)
to be used in Scala and
Groovy, where var
is a reserved keyword.var(Name, DataType)
to be used in Scala and
Groovy, where var
is a reserved keyword.
Declarations can be inlined in any statement Block
as is
supported by databases like SQLDialect.MYSQL
or
SQLDialect.SQLSERVER
. If the underlying database requires a
dedicated DECLARE
section, the section will be generated
automatically and if needed, a nested Block
is generated.
Declarations can be inlined in any statement Block
as is
supported by databases like SQLDialect.MYSQL
or
SQLDialect.SQLSERVER
. If the underlying database requires a
dedicated DECLARE
section, the section will be generated
automatically and if needed, a nested Block
is generated.
Declarations can be inlined in any statement Block
as is
supported by databases like SQLDialect.MYSQL
or
SQLDialect.SQLSERVER
. If the underlying database requires a
dedicated DECLARE
section, the section will be generated
automatically and if needed, a nested Block
is generated.
Many dialects support some way of running procedural and SQL statements dynamically from within procedural code. For example, in Oracle, this syntax is required to run DDL statements from PL/SQL:
BEGIN
EXECUTE IMMEDIATE 'CREATE TABLE x (i INT)';
END;
IF
statement for use in procedural code.WHILE
loop for use in procedural code.REPEAT
loop for use in procedural code.REPEAT
loop for use in procedural code.FOR
loop for use in procedural code.LOOP
for use in procedural code.LOOP
for use in procedural code.EXIT
statement for use in procedural code.EXIT
statement for use in procedural code.EXIT
statement for use in procedural code.EXIT
statement for use in procedural code.CONTINUE
statement for use in procedural code.CONTINUE
statement for use in procedural code.CONTINUE
statement for use in procedural code.CONTINUE
statement for use in procedural code.
A plain SQL QueryPart
is a QueryPart
that can
contain user-defined plain SQL, because sometimes it is easier to express
things directly in SQL.
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.A plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: A lot of things work less well in jOOQ if no
DataType
information is attached to a Field
expression,
including:
NULL
values.field(SQL, DataType)
, instead, or
even better, use code generation where possible: https://blog.jooq.org/why-you-should-use-jooq-with-code-generation/,
in case of which DataType
information is attached to all
Field
expressions automatically.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQLA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: A lot of things work less well in jOOQ if no
DataType
information is attached to a Field
expression,
including:
NULL
values.field(String, DataType)
, instead,
or even better, use code generation where possible: https://blog.jooq.org/why-you-should-use-jooq-with-code-generation/,
in case of which DataType
information is attached to all
Field
expressions automatically.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQLA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must be as many binding variables contained in the SQL, as passed in the bindings parameter
Example:
String sql = "DECODE(MY_FIELD, ?, ?, ?)";
Object[] bindings = new Object[] { 1, 100, 200 };
NOTE: A lot of things work less well in jOOQ if no
DataType
information is attached to a Field
expression,
including:
NULL
values.field(String, DataType, Object...)
, instead,
or even better, use code generation where possible: https://blog.jooq.org/why-you-should-use-jooq-with-code-generation/,
in case of which DataType
information is attached to all
Field
expressions automatically.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQLbindings
- The bindings for the fieldA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only Class
references of types supported by jOOQ internally, i.e. types from
SQLDataType
. If you're using any custom data types by means of a
Converter
or Binding
, it's better to pass that converted
DataType
reference explicitly to
field(SQL, DataType)
.
sql
- The SQLtype
- The field type (a type that is supported by
SQLDataType
)A plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
field(String, DataType)
.
sql
- The SQLtype
- The field type (a type that is supported by
SQLDataType
)A plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must be as many binding variables contained in the SQL, as passed in the bindings parameter
Example:
String sql = "DECODE(MY_FIELD, ?, ?, ?)";
Object[] bindings = new Object[] { 1, 100, 200 };
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
field(String, DataType, Object...)
.
sql
- The SQLtype
- The field type (a type that is supported by
SQLDataType
)bindings
- The bindings for the fieldA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQLtype
- The field typeA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
String sql = "DECODE(MY_FIELD, 1, 100, 200)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQLtype
- The field typeA plain SQL field is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must be as many binding variables contained in the SQL, as passed in the bindings parameter
Example:
String sql = "DECODE(MY_FIELD, ?, ?, ?)";
Object[] bindings = new Object[] { 1, 100, 200 };
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQLtype
- The field typebindings
- The bindings for the field
This is useful for constructing more complex SQL syntax elements wherever
Field
types are expected. An example for this is MySQL's
GROUP_CONCAT
aggregate function, which has MySQL-specific
keywords that are hard to reflect in jOOQ's DSL:
GROUP_CONCAT([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[SEPARATOR str_val])
The above MySQL function can be expressed as such:
field("GROUP_CONCAT(DISTINCT {0} ORDER BY {1} ASC SEPARATOR '-')", expr1, expr2);
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses! One way to escape
literals is to use name(String...)
and similar methods
sql
- The SQLtype
- The field typeparts
- The QueryPart
objects that are rendered at the
{numbered placeholder} locations
This is useful for constructing more complex SQL syntax elements wherever
Field
types are expected. An example for this is MySQL's
GROUP_CONCAT
aggregate function, which has MySQL-specific
keywords that are hard to reflect in jOOQ's DSL:
GROUP_CONCAT([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[SEPARATOR str_val])
The above MySQL function can be expressed as such:
field("GROUP_CONCAT(DISTINCT {0} ORDER BY {1} ASC SEPARATOR '-')", expr1, expr2);
NOTE: A lot of things work less well in jOOQ if no
DataType
information is attached to a Field
expression,
including:
NULL
values.field(String, DataType, QueryPart...)
, instead,
or even better, use code generation where possible: https://blog.jooq.org/why-you-should-use-jooq-with-code-generation/,
in case of which DataType
information is attached to all
Field
expressions automatically.
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses! One way to escape
literals is to use name(String...)
and similar methods
sql
- The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts
- The QueryPart
objects that are rendered at the
{numbered placeholder} locations
This is useful for constructing more complex SQL syntax elements wherever
Field
types are expected. An example for this is MySQL's
GROUP_CONCAT
aggregate function, which has MySQL-specific
keywords that are hard to reflect in jOOQ's DSL:
GROUP_CONCAT([DISTINCT] expr [,expr ...]
[ORDER BY {unsigned_integer | col_name | expr}
[ASC | DESC] [,col_name ...]]
[SEPARATOR str_val])
The above MySQL function can be expressed as such:
field("GROUP_CONCAT(DISTINCT {0} ORDER BY {1} ASC SEPARATOR '-')", expr1, expr2);
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses! One way to escape
literals is to use name(String...)
and similar methods
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
field(String, DataType, QueryPart...)
.
sql
- The SQL clause, containing {numbered placeholders} where query
parts can be injectedtype
- The field type (a type that is supported by
SQLDataType
)parts
- The QueryPart
objects that are rendered at the
{numbered placeholder} locationsfunction()
can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
function(String, DataType, Field...)
.
name
- The function name (without parentheses)type
- The function return type (a type that is supported by
SQLDataType
)arguments
- The function argumentsfunction()
can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
name
- The function name (without parentheses)type
- The function return typearguments
- The function argumentsfunction()
can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
function(Name, DataType, Field...)
.
name
- The function name (possibly qualified)type
- The function return type (a type that is supported by
SQLDataType
)arguments
- The function argumentsfunction()
can be used to access native or user-defined
functions that are not yet or insufficiently supported by jOOQ.name
- The function name (possibly qualified)type
- The function return typearguments
- The function argumentsaggregate()
can be used to access native or user-defined
aggregate functions that are not yet or insufficiently supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
aggregate(String, DataType, Field...)
.
name
- The aggregate function name (possibly qualified)type
- The aggregate function return type (a type that is supported
by SQLDataType
)arguments
- The aggregate function argumentsaggregate()
can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
name
- The aggregate function nametype
- The aggregate function return typearguments
- The aggregate function argumentsaggregate()
can be used to access native or user-defined
aggregate functions that are not yet or insufficiently supported by jOOQ.
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
aggregate(Name, DataType, Field...)
.
name
- The aggregate function name (possibly qualified)type
- The aggregate function return type (a type that is supported
by SQLDataType
)arguments
- The aggregate function argumentsaggregate()
can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.name
- The aggregate function name (possibly qualified)type
- The aggregate function return typearguments
- The aggregate function argumentsaggregateDistinct()
can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
aggregateDistinct(String, DataType, Field...)
.
name
- The aggregate function name (possibly qualified)type
- The aggregate function return type (a type that is supported
by SQLDataType
)arguments
- The aggregate function argumentsaggregateDistinct()
can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
name
- The aggregate function nametype
- The aggregate function return typearguments
- The aggregate function argumentsaggregateDistinct()
can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
aggregateDistinct(Name, DataType, Field...)
.
name
- The aggregate function name (possibly qualified)type
- The aggregate function return type (a type that is supported
by SQLDataType
)arguments
- The aggregate function argumentsaggregateDistinct()
can be used to access native or
user-defined aggregate functions that are not yet or insufficiently
supported by jOOQ.name
- The aggregate function name (possibly qualified)type
- The aggregate function return typearguments
- The aggregate function argumentsThere must not be any bind variables contained in the SQL.
Example:
String sql = "(X = 1 and Y = 2)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQLThere must not be any bind variables contained in the SQL.
Example:
String sql = "(X = 1 and Y = 2)";
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQLThere must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example:
String sql = "(X = ? and Y = ?)";
Object[] bindings = new Object[] { 1, 2 };
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
sql
- The SQLbindings
- The bindings
This is useful for constructing more complex SQL syntax elements wherever
Condition
types are expected. An example for this are
Postgres's various operators, some of which are missing in the jOOQ API.
For instance, the "overlap" operator for arrays:
ARRAY[1,4,3] && ARRAY[2,1]
The above Postgres operator can be expressed as such:
condition("{0} && {1}", array1, array2);
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses! One way to escape
literals is to use name(String...)
and similar methods
sql
- The SQLparts
- The QueryPart
objects that are rendered at the
{numbered placeholder} locationsDatabases that support boolean data types can use boolean expressions as predicates or as columns interchangeably. This extends to any type of field, including functions. A Postgres example:
select 1 where texteq('a', 'a');
value
- The boolean expression.
The result is a condition generated from keys and values of the argument map
, such that:
key1 = value1 AND key2 = value2 AND ... AND keyN = valueN
map
- A map containing keys and values to form predicates.Condition
from a Record
.
This will take all the non-null values in the argument
record
to form a predicate from them. If all values in the
record
are null
, the predicate will be the
trueCondition()
.
record
- The record from which to create a condition.Condition
that behaves like no condition being
present.
This is useful as an "identity" condition for reduction operations, for
both AND
and OR
reductions, e.g.
Condition combined =
Stream.of(cond1, cond2, cond3)
.reduce(noCondition(), Condition::and);
When this condition is passed to SQL clauses, such as the
WHERE
clause, the entire clause is omitted:
selectFrom(T).where(noCondition())
... will produce
SELECT * FROM t
NOTE [#16918] that this Condition
is meant to be used with the
DSL
API only, not with the QOM
API, which cannot offer
any no-op operations. The behaviour when used with the QOM
API is
undefined.
Condition
that will always evaluate to
TRUE
.Condition
that will always evaluate to
FALSE
.Condition
that will always evaluate to
NULL
.Condition
that connects all argument
conditions
with Operator
.Condition
that connects all argument
conditions
with Operator
.Condition
that connects all argument
conditions
with Operator
.FIELD(expr, expr1, expr2, …)
function.FIELD(expr, expr1, expr2, …)
function.SelectField
in a general-purpose Field
RowN
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 fieldvalue
- The value to be coercedas
- The field type (a type that is supported by
SQLDataType
)
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_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_XNOR
function.arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.BIT_XNOR
function.arg1
- is wrapped as val(Object)
.BIT_XNOR
function.arg2
- is wrapped as val(Object)
.BIT_XNOR
function.BIT_XOR
function.arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.BIT_XOR
function.arg1
- is wrapped as val(Object)
.BIT_XOR
function.arg2
- is wrapped as val(Object)
.BIT_XOR
function.CEIL
function.
Get the smallest integer value equal or greater to a value.
value
- is wrapped as val(Object)
.CEIL
function.
Get the smallest integer value equal or greater to a value.
COS
function.value
- is wrapped as val(Object)
.COS
function.COSH
function.value
- is wrapped as val(Object)
.COSH
function.COT
function.value
- is wrapped as val(Object)
.COT
function.COTH
function.value
- is wrapped as val(Object)
.COTH
function.DEGREES
function.
Turn a value in radians to degrees.
radians
- The value in radians.DEGREES
function.
Turn a value in radians to degrees.
radians
- The value in radians.E
function.
The E literal (Euler number).
EXP
function.value
- is wrapped as val(Object)
.EXP
function.FLOOR
function.
Get the biggest integer value equal or less than a value.
value
- is wrapped as val(Object)
.FLOOR
function.
Get the biggest integer value equal or less than a value.
LN
function.
Get the natural logarithm of a value.
value
- is wrapped as val(Object)
.LN
function.
Get the natural logarithm of a value.
LOG
function.
Get the logarithm of a value for a base.
value
- is wrapped as val(Object)
.base
- is wrapped as val(Object)
.LOG
function.
Get the logarithm of a value for a base.
value
- is wrapped as val(Object)
.LOG
function.
Get the logarithm of a value for a base.
base
- is wrapped as val(Object)
.LOG
function.
Get the logarithm of a value for a base.
LOG10
function.
Get the logarithm of a value for base 10.
value
- is wrapped as val(Object)
.LOG10
function.
Get the logarithm of a value for base 10.
PI
function.
The π literal.
POWER
function.base
- is wrapped as val(Object)
.exponent
- is wrapped as val(Object)
.POWER
function.base
- is wrapped as val(Object)
.POWER
function.exponent
- is wrapped as val(Object)
.POWER
function.RADIANS
function.
Turn a value in degrees to radians.
degrees
- The value in degrees.RADIANS
function.
Turn a value in degrees to radians.
degrees
- The value in degrees.RAND
function.
Get a random numeric value.
ROUND
function.
Round a numeric value to the nearest decimal precision.
value
- The number to be rounded.decimals
- The decimals to round to.ROUND
function.
Round a numeric value to the nearest decimal precision.
value
- The number to be rounded.decimals
- The decimals to round to.ROUND
function.
Round a numeric value to the nearest decimal precision.
value
- The number to be rounded.decimals
- The decimals to round to.ROUND
function.
Round a numeric value to the nearest decimal precision.
value
- The number to be rounded.decimals
- The decimals to round to.ROUND
function.
Round a numeric value to the nearest decimal precision.
value
- The number to be rounded.ROUND
function.
Round a numeric value to the nearest decimal precision.
value
- The number to be rounded.SHL
function.
Left shift all bits in a number
value
- The number whose bits to shift left.count
- The number of bits to shift.SHL
function.
Left shift all bits in a number
value
- The number whose bits to shift left.count
- The number of bits to shift.SHL
function.
Left shift all bits in a number
value
- The number whose bits to shift left.count
- The number of bits to shift.SHL
function.
Left shift all bits in a number
value
- The number whose bits to shift left.count
- The number of bits to shift.SHR
function.
Right shift all bits in a number
value
- The number whose bits to shift rightcount
- The number of bits to shift.SHR
function.
Right shift all bits in a number
value
- The number whose bits to shift rightcount
- The number of bits to shift.SHR
function.
Right shift all bits in a number
value
- The number whose bits to shift rightcount
- The number of bits to shift.SHR
function.
Right shift all bits in a number
value
- The number whose bits to shift rightcount
- The number of bits to shift.SIGN
function.
Get the sign of a number and return it as any of +1, 0, -1.
value
- is wrapped as val(Object)
.SIGN
function.
Get the sign of a number and return it as any of +1, 0, -1.
SIN
function.value
- is wrapped as val(Object)
.SIN
function.SINH
function.value
- is wrapped as val(Object)
.SINH
function.SQRT
function.value
- is wrapped as val(Object)
.SQRT
function.SQUARE
function.value
- is wrapped as val(Object)
.SQUARE
function.TAN
function.value
- is wrapped as val(Object)
.TAN
function.TANH
function.value
- is wrapped as val(Object)
.TANH
function.TAU
function.
The τ literal, or π, in a better world.
TRUNC
function.
Truncate a number to a given number of decimals.
value
- The number to be truncateddecimals
- The decimals to truncate to.TRUNC
function.
Truncate a number to a given number of decimals.
value
- The number to be truncateddecimals
- The decimals to truncate to.TRUNC
function.
Truncate a number to a given number of decimals.
value
- The number to be truncateddecimals
- The decimals to truncate to.TRUNC
function.
Truncate a number to a given number of decimals.
value
- The number to be truncateddecimals
- The decimals to truncate to.WIDTH_BUCKET
function.
Divide a range into buckets of equal size.
field
- The value to divide into the range.low
- The lower bound of the range.high
- The upper bound of the range.buckets
- The number of buckets to produce.WIDTH_BUCKET
function.
Divide a range into buckets of equal size.
field
- The value to divide into the range.low
- The lower bound of the range.high
- The upper bound of the range.buckets
- The number of buckets to produce.ASCII
function.
The ASCII value of a character.
string
- is wrapped as val(Object)
.ASCII
function.
The ASCII value of a character.
BIT_LENGTH
function.
The length of a string in bits.
string
- is wrapped as val(Object)
.BIT_LENGTH
function.
The length of a string in bits.
CHAR_LENGTH
function.
The length of a string in characters.
string
- is wrapped as val(Object)
.CHAR_LENGTH
function.
The length of a string in characters.
CHR
function.value
- is wrapped as val(Object)
.CHR
function.DIGITS
function.value
- is wrapped as val(Object)
.DIGITS
function.LEFT
function.
Get the left outermost characters from a string.
string
- The string whose characters are extracted.length
- The number of characters to extract from the string.LEFT
function.
Get the left outermost characters from a string.
string
- The string whose characters are extracted.length
- The number of characters to extract from the string.LEFT
function.
Get the left outermost characters from a string.
string
- The string whose characters are extracted.length
- The number of characters to extract from the string.LEFT
function.
Get the left outermost characters from a string.
string
- The string whose characters are extracted.length
- The number of characters to extract from the string.LENGTH
function, an alias for the CHAR_LENGTH
function.
The length of a string in characters.
string
- is wrapped as val(Object)
.LENGTH
function, an alias for the CHAR_LENGTH
function.
The length of a string in characters.
LOWER
function.
Turn a string into lower case.
string
- is wrapped as val(Object)
.LOWER
function.
Turn a string into lower case.
LPAD
function.
Left-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.character
- The padding character, if different from whitespaceLPAD
function.
Left-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.character
- The padding character, if different from whitespaceLPAD
function.
Left-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.character
- The padding character, if different from whitespaceLPAD
function.
Left-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.character
- The padding character, if different from whitespaceLPAD
function.
Left-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.LPAD
function.
Left-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.LTRIM
function.
Trim characters (whitespace as default) from the left side of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.LTRIM
function.
Trim characters (whitespace as default) from the left side of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.LTRIM
function.
Trim characters (whitespace as default) from the left side of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.LTRIM
function.
Trim characters (whitespace as default) from the left side of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.LTRIM
function.
Trim characters (whitespace as default) from the left side of a string.
string
- The string to be trimmed.LTRIM
function.
Trim characters (whitespace as default) from the left side of a string.
string
- The string to be trimmed.MD5
function.
Calculate an MD5 hash from a string.
string
- is wrapped as val(Object)
.MD5
function.
Calculate an MD5 hash from a string.
MID
function, an alias for the SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.length
- The maximum length of the substring.MID
function, an alias for the SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.length
- The maximum length of the substring.MID
function, an alias for the SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.length
- The maximum length of the substring.MID
function, an alias for the SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.length
- The maximum length of the substring.MID
function, an alias for the SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.MID
function, an alias for the SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.OCTET_LENGTH
function.
The length of a string in octets.
string
- is wrapped as val(Object)
.OCTET_LENGTH
function.
The length of a string in octets.
OVERLAY
function.
Place a string on top of another string, replacing the original contents.
in
- The original string on top of which the overlay is placed.placing
- The string that is being placed on top of the other string.startIndex
- The start index (1-based) starting from where the overlay is placed.length
- The length in the original string that will be replaced, if different from the overlay length.OVERLAY
function.
Place a string on top of another string, replacing the original contents.
in
- The original string on top of which the overlay is placed.placing
- The string that is being placed on top of the other string.startIndex
- The start index (1-based) starting from where the overlay is placed.length
- The length in the original string that will be replaced, if different from the overlay length.OVERLAY
function.
Place a string on top of another string, replacing the original contents.
in
- The original string on top of which the overlay is placed.placing
- The string that is being placed on top of the other string.startIndex
- The start index (1-based) starting from where the overlay is placed.OVERLAY
function.
Place a string on top of another string, replacing the original contents.
in
- The original string on top of which the overlay is placed.placing
- The string that is being placed on top of the other string.startIndex
- The start index (1-based) starting from where the overlay is placed.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.startIndex
- The start index (1-based) from which to start looking for the substring.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.startIndex
- The start index (1-based) from which to start looking for the substring.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.startIndex
- The start index (1-based) from which to start looking for the substring.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.startIndex
- The start index (1-based) from which to start looking for the substring.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.startIndex
- The start index (1-based) from which to start looking for the substring.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.startIndex
- The start index (1-based) from which to start looking for the substring.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.startIndex
- The start index (1-based) from which to start looking for the substring.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.startIndex
- The start index (1-based) from which to start looking for the substring.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.POSITION
function.
Search the position (1-based) of a substring in another string.
in
- The string in which to search the substring.search
- The substring to search for.REPEAT
function.
Repeat a string a number of times.
string
- The string to be repeated.count
- The number of times to repeat the string.REPEAT
function.
Repeat a string a number of times.
string
- The string to be repeated.count
- The number of times to repeat the string.REPEAT
function.
Repeat a string a number of times.
string
- The string to be repeated.count
- The number of times to repeat the string.REPEAT
function.
Repeat a string a number of times.
string
- The string to be repeated.count
- The number of times to repeat the string.REPLACE
function.
Replace all occurrences of a substring in another string.
string
- The string in which to replace contents.search
- The substring to search for.replace
- The replacement for each substring, if not empty.REPLACE
function.
Replace all occurrences of a substring in another string.
string
- The string in which to replace contents.search
- The substring to search for.replace
- The replacement for each substring, if not empty.REPLACE
function.
Replace all occurrences of a substring in another string.
string
- The string in which to replace contents.search
- The substring to search for.replace
- The replacement for each substring, if not empty.REPLACE
function.
Replace all occurrences of a substring in another string.
string
- The string in which to replace contents.search
- The substring to search for.replace
- The replacement for each substring, if not empty.REPLACE
function.
Replace all occurrences of a substring in another string.
string
- The string in which to replace contents.search
- The substring to search for.REPLACE
function.
Replace all occurrences of a substring in another string.
string
- The string in which to replace contents.search
- The substring to search for.REVERSE
function.
Reverse a string.
string
- is wrapped as val(Object)
.REVERSE
function.
Reverse a string.
RIGHT
function.
Get the right outermost characters from a string.
string
- The string whose characters are extracted.length
- The number of characters to extract from the string.RIGHT
function.
Get the right outermost characters from a string.
string
- The string whose characters are extracted.length
- The number of characters to extract from the string.RIGHT
function.
Get the right outermost characters from a string.
string
- The string whose characters are extracted.length
- The number of characters to extract from the string.RIGHT
function.
Get the right outermost characters from a string.
string
- The string whose characters are extracted.length
- The number of characters to extract from the string.RPAD
function.
Right-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.character
- The padding character, if different from whitespaceRPAD
function.
Right-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.character
- The padding character, if different from whitespaceRPAD
function.
Right-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.character
- The padding character, if different from whitespaceRPAD
function.
Right-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.character
- The padding character, if different from whitespaceRPAD
function.
Right-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.RPAD
function.
Right-pad a string with a character (whitespace as default) for a number of times.
string
- The string to be padded.length
- The maximum length to pad the string to.RTRIM
function.
Trim characters (whitespace as default) from the right side of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.RTRIM
function.
Trim characters (whitespace as default) from the right side of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.RTRIM
function.
Trim characters (whitespace as default) from the right side of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.RTRIM
function.
Trim characters (whitespace as default) from the right side of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.RTRIM
function.
Trim characters (whitespace as default) from the right side of a string.
string
- The string to be trimmed.RTRIM
function.
Trim characters (whitespace as default) from the right side of a string.
string
- The string to be trimmed.SPACE
function.
Get a string of spaces of a given length.
count
- The number of spaces to produce.SPACE
function.
Get a string of spaces of a given length.
count
- The number of spaces to produce.SPLIT_PART
function.
Split a string into tokens, and retrieve the nth token.
string
- The string to be split into parts.delimiter
- The delimiter used for splitting.n
- The token number (1-based).SPLIT_PART
function.
Split a string into tokens, and retrieve the nth token.
string
- The string to be split into parts.delimiter
- The delimiter used for splitting.n
- The token number (1-based).SPLIT_PART
function.
Split a string into tokens, and retrieve the nth token.
string
- The string to be split into parts.delimiter
- The delimiter used for splitting.n
- The token number (1-based).SPLIT_PART
function.
Split a string into tokens, and retrieve the nth token.
string
- The string to be split into parts.delimiter
- The delimiter used for splitting.n
- The token number (1-based).SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.length
- The maximum length of the substring.SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.length
- The maximum length of the substring.SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.length
- The maximum length of the substring.SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.length
- The maximum length of the substring.SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.SUBSTRING
function.
Get a substring of a string, from a given position.
string
- The string from which to get the substring.startingPosition
- The position (1-based) from which to get the substring.SUBSTRING_INDEX
function.
Get a substring of a string, from the beginning until the nth occurrence of a substring.
string
- The string from which to get the substring.delimiter
- The delimiter.n
- The number of occurrences of the delimiter.SUBSTRING_INDEX
function.
Get a substring of a string, from the beginning until the nth occurrence of a substring.
string
- The string from which to get the substring.delimiter
- The delimiter.n
- The number of occurrences of the delimiter.SUBSTRING_INDEX
function.
Get a substring of a string, from the beginning until the nth occurrence of a substring.
string
- The string from which to get the substring.delimiter
- The delimiter.n
- The number of occurrences of the delimiter.SUBSTRING_INDEX
function.
Get a substring of a string, from the beginning until the nth occurrence of a substring.
string
- The string from which to get the substring.delimiter
- The delimiter.n
- The number of occurrences of the delimiter.TO_CHAR
function.
Format an arbitrary value as a string.
value
- The value to be formatted.formatMask
- The vendor-specific formatting string.TO_CHAR
function.
Format an arbitrary value as a string.
value
- The value to be formatted.formatMask
- The vendor-specific formatting string.TO_CHAR
function.
Format an arbitrary value as a string.
value
- The value to be formatted.formatMask
- The vendor-specific formatting string.TO_CHAR
function.
Format an arbitrary value as a string.
value
- The value to be formatted.formatMask
- The vendor-specific formatting string.TO_CHAR
function.
Format an arbitrary value as a string.
value
- The value to be formatted.TO_CHAR
function.
Format an arbitrary value as a string.
value
- The value to be formatted.TO_DATE
function.
Parse a string-formatted date value to a date.
value
- The formatted DATE value.formatMask
- The vendor-specific formatting string.TO_DATE
function.
Parse a string-formatted date value to a date.
value
- The formatted DATE value.formatMask
- The vendor-specific formatting string.TO_DATE
function.
Parse a string-formatted date value to a date.
value
- The formatted DATE value.formatMask
- The vendor-specific formatting string.TO_DATE
function.
Parse a string-formatted date value to a date.
value
- The formatted DATE value.formatMask
- The vendor-specific formatting string.TO_HEX
function.
Format a number to its hex value.
value
- is wrapped as val(Object)
.TO_HEX
function.
Format a number to its hex value.
TO_TIMESTAMP
function.
Parse a string-formatted timestamp value to a timestamp.
value
- The formatted TIMESTAMP value.formatMask
- The vendor-specific formatting string.TO_TIMESTAMP
function.
Parse a string-formatted timestamp value to a timestamp.
value
- The formatted TIMESTAMP value.formatMask
- The vendor-specific formatting string.TO_TIMESTAMP
function.
Parse a string-formatted timestamp value to a timestamp.
value
- The formatted TIMESTAMP value.formatMask
- The vendor-specific formatting string.TO_TIMESTAMP
function.
Parse a string-formatted timestamp value to a timestamp.
value
- The formatted TIMESTAMP value.formatMask
- The vendor-specific formatting string.TRANSLATE
function.
Translate a set of characters to another set of characters in a string.
string
- The string to translate.from
- The set of source characters.to
- The set of target characters, matched with source characters by position.TRANSLATE
function.
Translate a set of characters to another set of characters in a string.
string
- The string to translate.from
- The set of source characters.to
- The set of target characters, matched with source characters by position.TRANSLATE
function.
Translate a set of characters to another set of characters in a string.
string
- The string to translate.from
- The set of source characters.to
- The set of target characters, matched with source characters by position.TRANSLATE
function.
Translate a set of characters to another set of characters in a string.
string
- The string to translate.from
- The set of source characters.to
- The set of target characters, matched with source characters by position.TRIM
function.
Trim characters (whitespace as default) from both sides of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.TRIM
function.
Trim characters (whitespace as default) from both sides of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.TRIM
function.
Trim characters (whitespace as default) from both sides of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.TRIM
function.
Trim characters (whitespace as default) from both sides of a string.
string
- The string to be trimmed.characters
- The characters to be trimmed.TRIM
function.
Trim characters (whitespace as default) from both sides of a string.
string
- The string to be trimmed.TRIM
function.
Trim characters (whitespace as default) from both sides of a string.
string
- The string to be trimmed.UPPER
function.
Turn a string into upper case.
string
- is wrapped as val(Object)
.UPPER
function.
Turn a string into upper case.
UUID
function.
Generate a random UUID.
DATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the datedatePart
- The date part describing the intervalDATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the datedatePart
- The date part describing the intervalDATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the datedatePart
- The date part describing the intervalDATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the datedatePart
- The date part describing the intervalDATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the dateDATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the dateDATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the dateDATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the dateLOCAL_DATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the datedatePart
- The date part describing the intervalLOCAL_DATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the datedatePart
- The date part describing the intervalLOCAL_DATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the datedatePart
- The date part describing the intervalLOCAL_DATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the datedatePart
- The date part describing the intervalLOCAL_DATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the dateLOCAL_DATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the dateLOCAL_DATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the dateLOCAL_DATE_ADD
function.
Add an interval to a date.
date
- The date to add an interval tointerval
- The interval to add to the dateTIMESTAMP_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampdatePart
- The date part describing the intervalTIMESTAMP_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampdatePart
- The date part describing the intervalTIMESTAMP_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampdatePart
- The date part describing the intervalTIMESTAMP_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampdatePart
- The date part describing the intervalTIMESTAMP_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampTIMESTAMP_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampTIMESTAMP_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampTIMESTAMP_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampLOCAL_DATE_TIME_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampdatePart
- The date part describing the intervalLOCAL_DATE_TIME_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampdatePart
- The date part describing the intervalLOCAL_DATE_TIME_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampdatePart
- The date part describing the intervalLOCAL_DATE_TIME_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampdatePart
- The date part describing the intervalLOCAL_DATE_TIME_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampLOCAL_DATE_TIME_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampLOCAL_DATE_TIME_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampLOCAL_DATE_TIME_ADD
function.
Add an interval to a timestamp.
date
- The timestamp to add an interval tointerval
- The interval to add to the timestampCARDINALITY
function.
Calculate the cardinality of an array field.
ARRAY_GET
function.
Get an array element at a given index (1 based).
index
- is wrapped as val(Object)
.ARRAY_GET
function.
Get an array element at a given index (1 based).
NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.ISNULL
function, an alias for the NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.ISNULL
function, an alias for the NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.ISNULL
function, an alias for the NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.ISNULL
function, an alias for the NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.IFNULL
function, an alias for the NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.IFNULL
function, an alias for the NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.IFNULL
function, an alias for the NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.IFNULL
function, an alias for the NVL
function.
Return the first non-null argument.
value
- The nullable value.defaultValue
- The default value if the other value is null.NULLIF
function.value
- The result value if the other value is not equal.other
- The value to compare the result value with.NULLIF
function.value
- The result value if the other value is not equal.other
- The value to compare the result value with.NULLIF
function.value
- The result value if the other value is not equal.other
- The value to compare the result value with.NULLIF
function.value
- The result value if the other value is not equal.other
- The value to compare the result value with.CURRENT_CATALOG
function.CURRENT_SCHEMA
function.CURRENT_USER
function.CONNECT_BY_ISCYCLE
function.
The CONNECT_BY_ISCYCLE pseudo column is used with the Oracle style CONNECT BY clause.
CONNECT_BY_ISLEAF
function.
The CONNECT_BY_ISLEAF pseudo column is used with the Oracle style CONNECT BY clause.
CONNECT_BY_ROOT
function.
The CONNECT_BY_ROOT operator is used with the Oracle style CONNECT BY clause.
LEVEL
function.
The LEVEL pseudo column is used with the Oracle style CONNECT BY clause.
PRIOR
function.
The PRIOR operator is used with the Oracle style CONNECT BY clause.
SYS_CONNECT_BY_PATH
function.
The SYS_CONNECT_BY_PATH function is used with the Oracle style CONNECT BY clause.
ROWNUM
function.
Depending on its usage, the Oracle-specific ROWNUM
pseudo-field can
be emulated using LIMIT
or ROW_NUMBER()
.
XMLCOMMENT
function.comment
- is wrapped as val(Object)
.XMLCOMMENT
function.XMLCONCAT
function.XMLCONCAT
function.XMLDOCUMENT
function.XMLFOREST
function.XMLFOREST
function.XMLPI
function.XMLPI
function.XMLPI
function.XMLPI
function.XMLSERIALIZE
function.value
- is wrapped as val(Object)
.XMLSERIALIZE
function.XMLSERIALIZE_CONTENT
function.value
- is wrapped as val(Object)
.XMLSERIALIZE_CONTENT
function.JSON_ARRAY
function.JSON_ARRAY
function.JSONB_ARRAY
function.JSONB_ARRAY
function.JSON_OBJECT
function.JSON_OBJECT
function.JSONB_OBJECT
function.JSONB_OBJECT
function.DELETING
function.INSERTING
function.UPDATING
function.FIELD
function.
Wrap a condition in a boolean field.
CONDITION
function.
Create a condition from a boolean field.
Databases that support boolean data types can use boolean expressions as predicates or as columns interchangeably. This extends to any type of field, including functions. A Postgres example:
select 1 where texteq('a', 'a');
ANY_VALUE
function.
Get any arbitrary value from the group.
AVG
function.AVG_DISTINCT
function.BIT_AND_AGG
function.
Calculate the bitwise AND
aggregate value.
BIT_OR_AGG
function.
Calculate the bitwise OR
aggregate value.
BIT_XOR_AGG
function.
Calculate the bitwise XOR
aggregate value.
BIT_NAND_AGG
function.
Calculate the bitwise NAND
aggregate value.
BIT_NOR_AGG
function.
Calculate the bitwise NOR
aggregate value.
BIT_XNOR_AGG
function.
Calculate the bitwise XNOR
aggregate value.
BOOL_AND
function.BOOL_AND
function.BOOL_OR
function.BOOL_OR
function.CORR
function.
Calculate the correlation coefficient. This standard SQL function may be supported
natively, or emulated using covarPop(Field, Field)
and stddevPop(Field)
.
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
COUNT
function.COUNT_DISTINCT
function.COVAR_SAMP
function.
Calculate the sample covariance. This standard SQL function may be supported natively,
or emulated using sum(Field)
and count(Field)
. If an emulation
is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
COVAR_POP
function.
Calculate the population covariance. This standard SQL function may be supported
natively, or emulated using sum(Field)
and count(Field)
. If an
emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
EVERY
function, an alias for the BOOL_AND
function.EVERY
function, an alias for the BOOL_AND
function.MAX
function.MAX_DISTINCT
function.MEDIAN
function.MIN
function.MIN_DISTINCT
function.PRODUCT
function.
Get the sum over a numeric field: product(distinct field).
Few dialects currently support multiplicative aggregation natively. jOOQ
emulates this using exp(sum(log(arg)))
for strictly positive
numbers, and does some additional handling for zero and negative numbers.
Note that this implementation may introduce rounding errors, even for integer multiplication.
More information here: https://blog.jooq.org/how-to-write-a-multiplication-aggregate-function-in-sql.
PRODUCT_DISTINCT
function.
Get the sum over a numeric field: product(distinct field).
Few dialects currently support multiplicative aggregation natively. jOOQ
emulates this using exp(sum(log(arg)))
for strictly positive
numbers, and does some additional handling for zero and negative numbers.
Note that this implementation may introduce rounding errors, even for integer multiplication.
More information here: https://blog.jooq.org/how-to-write-a-multiplication-aggregate-function-in-sql.
REGR_AVGX
function.
Calculate the average of the independent values (x). This standard SQL function may
be supported natively, or emulated using sum(Field)
and count(Field)
.
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_AVGY
function.
Calculate the average of the dependent values (y). This standard SQL function may
be supported natively, or emulated using sum(Field)
and count(Field)
.
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_COUNT
function.
Calculate the number of non-NULL
pairs. This standard SQL function may
be supported natively, or emulated using sum(Field)
and count(Field)
.
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_INTERCEPT
function.
Calculate the y intercept of the regression line. This standard SQL function may
be supported natively, or emulated using sum(Field)
and count(Field)
.
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_R2
function.
Calculate the coefficient of determination. This standard SQL function may be supported
natively, or emulated using sum(Field)
and count(Field)
. If an
emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_SLOPE
function.
Calculate the slope of the regression line. This standard SQL function may be supported
natively, or emulated using sum(Field)
and count(Field)
. If an
emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_SXX
function.
Calculate the REGR_SXX
auxiliary function. This standard SQL function
may be supported natively, or emulated using sum(Field)
and count(Field)
.
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_SXY
function.
Calculate the REGR_SXY
auxiliary function. This standard SQL function
may be supported natively, or emulated using sum(Field)
and count(Field)
.
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
REGR_SYY
function.
Calculate the REGR_SYY
auxiliary function. This standard SQL function
may be supported natively, or emulated using sum(Field)
and count(Field)
.
If an emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
STDDEV_POP
function.
Calculate the population standard deviation. This standard SQL function may be supported
natively, or emulated using sum(Field)
and count(Field)
. If an
emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
STDDEV_SAMP
function.
Calculate the sample standard deviation. This standard SQL function may be supported
natively, or emulated using sum(Field)
and count(Field)
. If an
emulation is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
SUM
function.SUM_DISTINCT
function.VAR_POP
function.
Calculate the population variance. This standard SQL function may be supported natively,
or emulated using sum(Field)
and count(Field)
. If an emulation
is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
VAR_SAMP
function.
Calculate the sample variance. This standard SQL function may be supported natively,
or emulated using sum(Field)
and count(Field)
. If an emulation
is applied, beware of the risk of "Catastrophic
cancellation" in case the calculations are performed using floating point arithmetic.
GOTO
function.EXECUTE
function.
Execute a statement dynamically from within procedural code.
Many dialects support some way of running procedural and SQL statements dynamically from within procedural code. For example, in Oracle, this syntax is required to run DDL statements from PL/SQL:
BEGIN
EXECUTE IMMEDIATE 'CREATE TABLE x (i INT)';
END;
sql
- is wrapped as val(Object)
.EXECUTE
function.
Execute a statement dynamically from within procedural code.
Many dialects support some way of running procedural and SQL statements dynamically from within procedural code. For example, in Oracle, this syntax is required to run DDL statements from PL/SQL:
BEGIN
EXECUTE IMMEDIATE 'CREATE TABLE x (i INT)';
END;
RETURN_
function.value
- is wrapped as val(Object)
.RETURN_
function.RETURN_
function.SIGNAL_SQLSTATE
function.value
- is wrapped as val(Object)
.SIGNAL_SQLSTATE
function.ST_AREA
function.
Calculate the area from a spatial type.
value
- is wrapped as val(Object)
.ST_AREA
function.
Calculate the area from a spatial type.
ST_ASBINARY
function.
Create a WKB representation from a spatial type.
value
- is wrapped as val(Object)
.ST_ASBINARY
function.
Create a WKB representation from a spatial type.
ST_ASTEXT
function.
Create a text representation from a spatial type.
value
- is wrapped as val(Object)
.ST_ASTEXT
function.
Create a text representation from a spatial type.
ST_CENTROID
function.
Get the geometric center of a spatial value.
value
- is wrapped as val(Object)
.ST_CENTROID
function.
Get the geometric center of a spatial value.
ST_CONTAINS
function.
Check if a spatial value contains another.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_CONTAINS
function.
Check if a spatial value contains another.
arg1
- is wrapped as val(Object)
.ST_CONTAINS
function.
Check if a spatial value contains another.
arg2
- is wrapped as val(Object)
.ST_CONTAINS
function.
Check if a spatial value contains another.
ST_CROSSES
function.
Check if a geometry crosses another.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_CROSSES
function.
Check if a geometry crosses another.
arg1
- is wrapped as val(Object)
.ST_CROSSES
function.
Check if a geometry crosses another.
arg2
- is wrapped as val(Object)
.ST_CROSSES
function.
Check if a geometry crosses another.
ST_DIFFERENCE
function.
Get the difference of two spatial values.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_DIFFERENCE
function.
Get the difference of two spatial values.
arg1
- is wrapped as val(Object)
.ST_DIFFERENCE
function.
Get the difference of two spatial values.
arg2
- is wrapped as val(Object)
.ST_DIFFERENCE
function.
Get the difference of two spatial values.
ST_DISJOINT
function.
Check if a spatial value is disjoint from another.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_DISJOINT
function.
Check if a spatial value is disjoint from another.
arg1
- is wrapped as val(Object)
.ST_DISJOINT
function.
Check if a spatial value is disjoint from another.
arg2
- is wrapped as val(Object)
.ST_DISJOINT
function.
Check if a spatial value is disjoint from another.
ST_DISTANCE
function.
Get the distance between two spatial values.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_DISTANCE
function.
Get the distance between two spatial values.
arg1
- is wrapped as val(Object)
.ST_DISTANCE
function.
Get the distance between two spatial values.
arg2
- is wrapped as val(Object)
.ST_DISTANCE
function.
Get the distance between two spatial values.
ST_ENDPOINT
function.
Get the end point of a spatial value.
value
- is wrapped as val(Object)
.ST_ENDPOINT
function.
Get the end point of a spatial value.
ST_EQUALS
function.
Check if a spatial value is equal to another.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_EQUALS
function.
Check if a spatial value is equal to another.
arg1
- is wrapped as val(Object)
.ST_EQUALS
function.
Check if a spatial value is equal to another.
arg2
- is wrapped as val(Object)
.ST_EQUALS
function.
Check if a spatial value is equal to another.
ST_EXTERIORRING
function.
Get the exterior ring of a spatial value.
value
- is wrapped as val(Object)
.ST_EXTERIORRING
function.
Get the exterior ring of a spatial value.
ST_GEOMETRYN
function.
Get the N-th geometry from a collection of spatial values.
value
- is wrapped as val(Object)
.position
- is wrapped as val(Object)
.ST_GEOMETRYN
function.
Get the N-th geometry from a collection of spatial values.
value
- is wrapped as val(Object)
.ST_GEOMETRYN
function.
Get the N-th geometry from a collection of spatial values.
position
- is wrapped as val(Object)
.ST_GEOMETRYN
function.
Get the N-th geometry from a collection of spatial values.
ST_GEOMETRYTYPE
function.
Get the geometry type of a spatial value.
value
- is wrapped as val(Object)
.ST_GEOMETRYTYPE
function.
Get the geometry type of a spatial value.
ST_GEOMFROMTEXT
function.
Create a geometry from a text representation.
text
- is wrapped as val(Object)
.ST_GEOMFROMTEXT
function.
Create a geometry from a text representation.
text
- is wrapped as val(Object)
.ST_GEOMFROMTEXT
function.
Create a geometry from a text representation.
ST_GEOMFROMTEXT
function.
Create a geometry from a text representation.
ST_GEOMFROMTEXT
function.
Create a geometry from a text representation.
text
- is wrapped as val(Object)
.ST_GEOMFROMTEXT
function.
Create a geometry from a text representation.
ST_GEOMFROMWKB
function.
Create a geometry from a binary representation.
ST_GEOMFROMWKB
function.
Create a geometry from a binary representation.
ST_GEOMFROMWKB
function.
Create a geometry from a binary representation.
ST_GEOMFROMWKB
function.
Create a geometry from a binary representation.
ST_GEOMFROMWKB
function.
Create a geometry from a binary representation.
ST_GEOMFROMWKB
function.
Create a geometry from a binary representation.
ST_INTERIORRINGN
function.
Get the N-th interior ring of a spatial value.
value
- is wrapped as val(Object)
.position
- is wrapped as val(Object)
.ST_INTERIORRINGN
function.
Get the N-th interior ring of a spatial value.
value
- is wrapped as val(Object)
.ST_INTERIORRINGN
function.
Get the N-th interior ring of a spatial value.
position
- is wrapped as val(Object)
.ST_INTERIORRINGN
function.
Get the N-th interior ring of a spatial value.
ST_INTERSECTION
function.
Get the intersection of two spatial values.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_INTERSECTION
function.
Get the intersection of two spatial values.
arg1
- is wrapped as val(Object)
.ST_INTERSECTION
function.
Get the intersection of two spatial values.
arg2
- is wrapped as val(Object)
.ST_INTERSECTION
function.
Get the intersection of two spatial values.
ST_INTERSECTS
function.
Check whether two spatial values intersect.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_INTERSECTS
function.
Check whether two spatial values intersect.
arg1
- is wrapped as val(Object)
.ST_INTERSECTS
function.
Check whether two spatial values intersect.
arg2
- is wrapped as val(Object)
.ST_INTERSECTS
function.
Check whether two spatial values intersect.
ST_ISCLOSED
function.
Check whether a spatial value is closed.
value
- is wrapped as val(Object)
.ST_ISCLOSED
function.
Check whether a spatial value is closed.
ST_ISEMPTY
function.
Check whether a spatial value is empty.
value
- is wrapped as val(Object)
.ST_ISEMPTY
function.
Check whether a spatial value is empty.
ST_LENGTH
function.
Get the length of a spatial value.
value
- is wrapped as val(Object)
.ST_LENGTH
function.
Get the length of a spatial value.
ST_NUMGEOMETRIES
function.
Get the number of geometries in a collection of spatial values.
value
- is wrapped as val(Object)
.ST_NUMGEOMETRIES
function.
Get the number of geometries in a collection of spatial values.
ST_NUMINTERIORRING
function.
Get the number of interior rings of a spatial value.
value
- is wrapped as val(Object)
.ST_NUMINTERIORRING
function.
Get the number of interior rings of a spatial value.
ST_NUMPOINTS
function.
Get the number of points in a spatial value.
value
- is wrapped as val(Object)
.ST_NUMPOINTS
function.
Get the number of points in a spatial value.
ST_OVERLAPS
function.
Check whether two spatial values overlap.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_OVERLAPS
function.
Check whether two spatial values overlap.
arg1
- is wrapped as val(Object)
.ST_OVERLAPS
function.
Check whether two spatial values overlap.
arg2
- is wrapped as val(Object)
.ST_OVERLAPS
function.
Check whether two spatial values overlap.
ST_POINTN
function.
Get the Nth point of a spatial value.
value
- The spatial value whose Nth point to findposition
- The 1-based positionST_POINTN
function.
Get the Nth point of a spatial value.
value
- The spatial value whose Nth point to findposition
- The 1-based positionST_POINTN
function.
Get the Nth point of a spatial value.
value
- The spatial value whose Nth point to findposition
- The 1-based positionST_POINTN
function.
Get the Nth point of a spatial value.
value
- The spatial value whose Nth point to findposition
- The 1-based positionST_SRID
function.
Get the SRID of a spatial value.
value
- is wrapped as val(Object)
.ST_SRID
function.
Get the SRID of a spatial value.
ST_STARTPOINT
function.
Get the start point of a spatial value.
value
- is wrapped as val(Object)
.ST_STARTPOINT
function.
Get the start point of a spatial value.
ST_TOUCHES
function.
Check whether two spatial values touch.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_TOUCHES
function.
Check whether two spatial values touch.
arg1
- is wrapped as val(Object)
.ST_TOUCHES
function.
Check whether two spatial values touch.
arg2
- is wrapped as val(Object)
.ST_TOUCHES
function.
Check whether two spatial values touch.
ST_UNION
function.
Get the union of two spatial values.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_UNION
function.
Get the union of two spatial values.
arg1
- is wrapped as val(Object)
.ST_UNION
function.
Get the union of two spatial values.
arg2
- is wrapped as val(Object)
.ST_UNION
function.
Get the union of two spatial values.
ST_WITHIN
function.
Check if a spatial value is contained within another.
arg1
- is wrapped as val(Object)
.arg2
- is wrapped as val(Object)
.ST_WITHIN
function.
Check if a spatial value is contained within another.
arg1
- is wrapped as val(Object)
.ST_WITHIN
function.
Check if a spatial value is contained within another.
arg2
- is wrapped as val(Object)
.ST_WITHIN
function.
Check if a spatial value is contained within another.
ST_X
function.
Extract the X coordinate from the argument geometry.
value
- is wrapped as val(Object)
.ST_X
function.
Extract the X coordinate from the argument geometry.
ST_Y
function.
Extract the Y coordinate from the argument geometry.
value
- is wrapped as val(Object)
.ST_Y
function.
Extract the Y coordinate from the argument geometry.
ST_Z
function.
Extract the Z coordinate from the argument geometry.
value
- is wrapped as val(Object)
.ST_Z
function.
Extract the Z coordinate from the argument geometry.
replace(Field, String, String)
to escape
data for use with Field.like(Field, char)
.
Essentially, this escapes %
and _
characters
replace(Field, String, String)
to escape
data for use with Field.like(Field, char)
.
Essentially, this escapes %
and _
characters
REGEXP_REPLACE_ALL
function.REGEXP_REPLACE_ALL
function.REGEXP_REPLACE_ALL
function.REGEXP_REPLACE_ALL
function.concat(field, value)
function.concat(value, field)
function.
This creates fields[0] || fields[1] || …
as an
expression, or concat(fields[0], fields[1], …)
,
depending on the dialect.
If any of the given fields is not a String
field, they are cast
to Field<String>
first using cast(Object, Class)
SQLDataType.DATE
type.
Note, while there is a CURRENT_DATE
function in
SQLDialect.ORACLE
, that function returns a seconds-precision
SQLDataType.TIMESTAMP
, which is undesired from a vendor
agnosticity perspective. This function thus produces an expression that
conforms to the SQL standard idea of a SQLDataType.DATE
type.
This translates into any dialect
SQLDataType.TIME
type.
This translates into any dialect
SQLDataType.TIMESTAMP
type.
This translates into any dialect
SQLDataType.TIMESTAMP
type with the specified fractional
seconds precision.SQLDataType.TIMESTAMP
type with the specified fractional
seconds precision.currentTimestamp()
.currentTimestamp(Field)
.SQLDataType.DATE
type.
Note, while there is a CURRENT_DATE
function in
SQLDialect.ORACLE
, that function returns a seconds-precision
SQLDataType.TIMESTAMP
, which is undesired from a vendor
agnosticity perspective. This function thus produces an expression that
conforms to the SQL standard idea of a SQLDataType.DATE
type.
This translates into any dialect
SQLDataType.TIME
type.
This translates into any dialect
SQLDataType.TIMESTAMP
type.
This translates into any dialect
SQLDataType.TIMESTAMP
type with the specified fractional
seconds precision.SQLDataType.TIMESTAMP
type with the specified fractional
seconds precision.This translates into any dialect
This translates into any dialect
This translates into any dialect
endDate - startDate
in
number of days.endDate - startDate
in
number of days.endDate - startDate
in
number of days.endDate - startDate
in
number of days.endDate - startDate
in terms
of part
.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
endDate - startDate
in terms
of part
.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in
number of days.endDate - startDate
in
number of days.endDate - startDate
in
number of days.endDate - startDate
in
number of days.endDate - startDate
in terms
of part
.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example, DATEDIFF(YEAR, '2000-03-01', '2002-01-01') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
INTERVAL DAY TO SECOND
type.
This translates into any dialect
endDate - startDate
in terms
of part
.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
endDate - startDate
in terms
of part
.
For example,
TIMESTAMPDIFF(YEAR, '2000-03-01 00:00:00', '2002-01-01 00:00:00') = 2
,
despite there being less than 2 years between the two days. The behaviour
replicates that of SQL Server.
This translates into any dialect
This translates into any dialect
This translates into any dialect
This is the same as calling extract(Field, DatePart)
with DatePart.EPOCH
This is the same as calling extract(Field, DatePart)
with DatePart.EPOCH
This is the same as calling extract(Field, DatePart)
with DatePart.EPOCH
This is the same as calling extract(Field, DatePart)
with DatePart.MILLENNIUM
This is the same as calling extract(Field, DatePart)
with DatePart.MILLENNIUM
This is the same as calling extract(Field, DatePart)
with DatePart.MILLENNIUM
This is the same as calling extract(Field, DatePart)
with DatePart.CENTURY
This is the same as calling extract(Field, DatePart)
with DatePart.CENTURY
This is the same as calling extract(Field, DatePart)
with DatePart.CENTURY
This is the same as calling extract(Field, DatePart)
with DatePart.DECADE
This is the same as calling extract(Field, DatePart)
with DatePart.DECADE
This is the same as calling extract(Field, DatePart)
with DatePart.DECADE
This is the same as calling extract(Field, DatePart)
with DatePart.QUARTER
This is the same as calling extract(Field, DatePart)
with DatePart.QUARTER
This is the same as calling extract(Field, DatePart)
with DatePart.QUARTER
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.YEAR
This is the same as calling extract(Temporal, DatePart)
with DatePart.YEAR
This is the same as calling extract(Field, DatePart)
with DatePart.YEAR
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.MONTH
This is the same as calling extract(Temporal, DatePart)
with DatePart.MONTH
This is the same as calling extract(Field, DatePart)
with DatePart.MONTH
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.WEEK
This is the same as calling extract(Temporal, DatePart)
with DatePart.WEEK
This is the same as calling extract(Field, DatePart)
with DatePart.WEEK
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.DAY
This is the same as calling extract(Temporal, DatePart)
with DatePart.DAY
This is the same as calling extract(Field, DatePart)
with DatePart.DAY
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.DAY_OF_WEEK
This is the same as calling extract(Temporal, DatePart)
with DatePart.DAY_OF_WEEK
This is the same as calling extract(Field, DatePart)
with DatePart.DAY_OF_WEEK
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.ISO_DAY_OF_WEEK
This is the same as calling extract(Temporal, DatePart)
with DatePart.ISO_DAY_OF_WEEK
This is the same as calling extract(Field, DatePart)
with DatePart.ISO_DAY_OF_WEEK
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.DAY_OF_YEAR
This is the same as calling extract(Temporal, DatePart)
with DatePart.DAY_OF_YEAR
This is the same as calling extract(Field, DatePart)
with DatePart.DAY_OF_YEAR
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.HOUR
This is the same as calling extract(Temporal, DatePart)
with DatePart.HOUR
This is the same as calling extract(Field, DatePart)
with DatePart.HOUR
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.MINUTE
This is the same as calling extract(Temporal, DatePart)
with DatePart.MINUTE
This is the same as calling extract(Field, DatePart)
with DatePart.MINUTE
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.SECOND
This is the same as calling extract(Temporal, DatePart)
with DatePart.SECOND
This is the same as calling extract(Field, DatePart)
with DatePart.SECOND
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.MILLISECOND
This is the same as calling extract(Temporal, DatePart)
with DatePart.MILLISECOND
This is the same as calling extract(Field, DatePart)
with DatePart.MILLISECOND
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.MICROSECOND
This is the same as calling extract(Temporal, DatePart)
with DatePart.MICROSECOND
This is the same as calling extract(Field, DatePart)
with DatePart.MICROSECOND
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.TIMEZONE
This is the same as calling extract(Temporal, DatePart)
with DatePart.TIMEZONE
This is the same as calling extract(Field, DatePart)
with DatePart.TIMEZONE
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.TIMEZONE_HOUR
This is the same as calling extract(Temporal, DatePart)
with DatePart.TIMEZONE_HOUR
This is the same as calling extract(Field, DatePart)
with DatePart.TIMEZONE_HOUR
This is the same as calling extract(java.util.Date, DatePart)
with DatePart.TIMEZONE_MINUTE
This is the same as calling extract(Temporal, DatePart)
with DatePart.TIMEZONE_MINUTE
This is the same as calling extract(Field, DatePart)
with DatePart.TIMEZONE_MINUTE
DATE
.DATE
.DATE
.TIME
.TIME
.TIME
.TIMESTAMP
.TIMESTAMP
.TIMESTAMP
.DATE
.DATE
.DATE
.TIME
.TIME
.TIME
.TIMESTAMP
.TIMESTAMP
.TIMESTAMP
.TIME WITH TIME ZONE
.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE
) or not (e.g.
SQLDialect.POSTGRES
), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant
(in UTC) as the input.
TIME WITH TIME ZONE
.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE
) or not (e.g.
SQLDialect.POSTGRES
), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant
(in UTC) as the input.
TIME WITH TIME ZONE
.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE
) or not (e.g.
SQLDialect.POSTGRES
), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant
(in UTC) as the input.
TIMESTAMP WITH TIME ZONE
.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE
) or not (e.g.
SQLDialect.POSTGRES
), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant
(in UTC) as the input.
TIMESTAMP WITH TIME ZONE
.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE
) or not (e.g.
SQLDialect.POSTGRES
), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant
(in UTC) as the input.
TIMESTAMP WITH TIME ZONE
.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE
) or not (e.g.
SQLDialect.POSTGRES
), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant
(in UTC) as the input.
TIMESTAMP WITH TIME ZONE
.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE
) or not (e.g.
SQLDialect.POSTGRES
), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant
(in UTC) as the input.
TIMESTAMP WITH TIME ZONE
.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE
) or not (e.g.
SQLDialect.POSTGRES
), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant
(in UTC) as the input.
TIMESTAMP WITH TIME ZONE
.
Depending on whether the database preserves the time zone information
(e.g. SQLDialect.ORACLE
) or not (e.g.
SQLDialect.POSTGRES
), the resulting value might be converted to
UTC. Regardless of this fact, the result should be the same
Instant
(in UTC) as the input.
DATE
.value
- The formatted DATE
value.format
- The vendor-specific formatting string.DATE
.value
- The formatted DATE
value.format
- The vendor-specific formatting string.DATE
.value
- The formatted DATE
value.format
- The vendor-specific formatting string.DATE
.value
- The formatted DATE
value.format
- The vendor-specific formatting string.TIMESTAMP
.value
- The formatted TIMESTAMP
value.format
- The vendor-specific formatting string.TIMESTAMP
.value
- The formatted TIMESTAMP
value.format
- The vendor-specific formatting string.TIMESTAMP
.value
- The formatted TIMESTAMP
value.format
- The vendor-specific formatting string.TIMESTAMP
.value
- The formatted TIMESTAMP
value.format
- The vendor-specific formatting string.
Please check the SQL Server documentation for a very nice explanation of
CUBE
, ROLLUP
, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fields
- The fields that are part of the GROUPING SETS
functionGROUP BY
clause
Please check the SQL Server documentation for a very nice explanation of
CUBE
, ROLLUP
, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fields
- The fields that are part of the ROLLUP
functionGROUP BY
clause
Please check the SQL Server documentation for a very nice explanation of
CUBE
, ROLLUP
, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fields
- The fields that are part of the CUBE
functionGROUP BY
clause
Please check the SQL Server documentation for a very nice explanation of
CUBE
, ROLLUP
, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fields
- The fields that are part of the GROUPING SETS
functionGROUP BY
clause
Please check the SQL Server documentation for a very nice explanation of
CUBE
, ROLLUP
, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fieldSets
- The fields that are part of the GROUPING SETS
functionGROUP BY
clause
Please check the SQL Server documentation for a very nice explanation of
CUBE
, ROLLUP
, and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
fieldSets
- The fields that are part of the GROUPING SETS
functionGROUP BY
clauseGROUP_ID()
aggregation function to be used along
with CUBE
, ROLLUP
, and
GROUPING SETS
groupings.GROUPING
aggregation fieldCUBE
, ROLLUP
, and
GROUPING SETS
groupings.
This has been observed to work with the following databases:
fields
- The function argumentsGROUPING_ID
aggregation fieldCUBE
, ROLLUP
, and GROUPING SETS
groupings.
This has been observed to work with the following databases:
field
- The function argumentGROUPING
aggregation field
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere. Its current simulation implementation has
O(2^n)
complexity and should be avoided for
n > 5
! Better implementation suggestions are very
welcome.
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere. Its current simulation implementation has
O(2^n)
complexity and should be avoided for
n > 5
! Better implementation suggestions are very
welcome.
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere. Its current simulation implementation has
O(2^n)
complexity and should be avoided for
n > 5
! Better implementation suggestions are very
welcome.
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere. Its current simulation implementation has
O(2^n)
complexity and should be avoided for
n > 5
! Better implementation suggestions are very
welcome.
jsonObject(JSONEntry...)
.
This is the same as calling jsonEntry(String, Field)
.
jsonObject(JSONEntry...)
.
This is the same as calling jsonEntry(Field, Field)
.
jsonObject(JSONEntry...)
.
This is the same as calling jsonEntry(String, Field)
with
Field.getName()
as a key.
jsonObject(JSONEntry...)
.jsonObject(JSONEntry...)
.jsonObject(JSONEntry...)
.jsonObject(JSONEntry...)
.jsonObject(JSONEntry...)
.jsonObject(JSONEntry...)
.Field
arguments in this method is inconsistent with that of other
overloads, such as #jsonbObject(Field, Field)
, which
can lead to subtle bugs. Please refrain from using this
overload as it will be removed in the future. Use
jsonObject(JSONEntry...)
instead.JSON_OBJECT
function.
This is the same as calling jsonEntry(String, Field)
with
Field.getName()
as a key.
This is the same as calling jsonEntry(String, Field)
with
Field.getName()
as a key.
array(select)
function.
Example:
{1, 2, 3} = array(select 1 union select 2 union select 3)
MULTISET
operator to nest subqueries.
The standard SQL MULTISET
operator is emulated using
elaborate mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
An important limitation is that correlating MULTISET
subqueries currently only works on dialects that support correlating
derived tables. This excludes:
See also https://github.com/jOOQ/jOOQ/issues/12045.
The various multisetAgg(Field...)
overloads are not affected
from this limitation.
If this is not supported by a given database (i.e. non
SQLDialect.POSTGRES
, then the primary key is used with
count(Field)
, instead.
If this is not supported by a given database (i.e. non
SQLDialect.POSTGRES
, then the primary key is used with
count(Field)
, instead.
Some dialects support several expressions in the
COUNT(DISTINCT expr1, expr2)
aggregate function.
SQLDialect.POSTGRES
supports this as
COUNT(DISTINCT(expr1, expr2))
.
array_agg()
aggregate function.array_agg()
aggregate function.MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
MULTISET_AGG
aggregate function to nest group
contents.
This synthetic, non-standard aggregate function works in a similar way as
the standard SQL ARRAY_AGG
aggregate function. It is
emulated using mappings to any of:
NestedCollectionEmulation.JSON
: A MULTISET of ROW types works
just like a jsonArrayAgg(Field)
of
jsonObject(Field...)
, or an application of
SelectForStep.forJSON()
. jOOQ produces a JSON encoding that is
compatible with DSLContext.fetchFromJSON(String)
. Future jOOQ
versions will make this format configurable according to
JSONFormat.RecordFormat
.NestedCollectionEmulation.JSONB
: Just like JSON
,
but we're using jsonbArrayAgg(Field)
and
#jsonbObject(Field...)
, or SelectForStep.forJSONB()
.NestedCollectionEmulation.XML
: A MULTISET of ROW types works
just like a xmlagg(Field)
of
xmlelement(Name, Field...)
, or an application of
SelectForStep.forXML()
. jOOQ produces an XML encoding that is
compatible with DSLContext.fetchFromXML(String)
. Future jOOQ
versions will make this format configurable according to
XMLFormat.RecordFormat
.NestedCollectionEmulation.NATIVE
: A few dialects have native
support for MULTISET.NestedCollectionEmulation.DEFAULT
: By default, jOOQ chooses
the optimal encoding among the above depending on your dialect,
transparently.
The emulation to be chosen is governed by
Settings.getEmulateMultiset()
.
collect()
aggregate function.
In Oracle, a standalone collect()
expression generates an
anonymous collection type, which can be used by clients only if cast
explicitly to a user-defined collection type. The latter can be supplied
here for convenience as the second argument.
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
collect(Field, DataType)
.
collect()
aggregate function.
In Oracle, a standalone collect()
expression generates an
anonymous collection type, which can be used by clients only if cast
explicitly to a user-defined collection type. The latter can be supplied
here for convenience as the second argument.
collect()
aggregate function.
In Oracle, a standalone collect()
expression generates an
anonymous collection type, which can be used by clients only if cast
explicitly to a user-defined collection type. The latter can be supplied
here for convenience as the second argument.
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
collectDistinct(Field, DataType)
.
collect()
aggregate function.
In Oracle, a standalone collect()
expression generates an
anonymous collection type, which can be used by clients only if cast
explicitly to a user-defined collection type. The latter can be supplied
here for convenience as the second argument.
mode(field)
aggregate function.
This is natively supported by SQLDialect.ORACLE11G
upwards. It is
emulated by the following dialects:
SQLDialect.AURORA_MYSQL
: Using GROUP_CONCAT
SQLDialect.DB2
: Using XMLAGG()
SQLDialect.H2
: Using GROUP_CONCAT()
SQLDialect.HSQLDB
: Using GROUP_CONCAT()
SQLDialect.MYSQL
: Using GROUP_CONCAT()
SQLDialect.POSTGRES
: Using STRING_AGG()
SQLDialect.SYBASE
: Using LIST()
This is natively supported by SQLDialect.ORACLE11G
upwards. It is
emulated by the following dialects:
SQLDialect.AURORA_MYSQL
: Using GROUP_CONCAT
SQLDialect.DB2
: Using XMLAGG()
SQLDialect.H2
: Using GROUP_CONCAT
SQLDialect.HSQLDB
: Using GROUP_CONCAT
SQLDialect.MYSQL
: Using GROUP_CONCAT
SQLDialect.POSTGRES
: Using STRING_AGG()
SQLDialect.SYBASE
: Using LIST()
This is natively supported by
SQLDialect.AURORA_MYSQL
SQLDialect.H2
SQLDialect.HSQLDB
SQLDialect.MEMSQL
(but without ORDER BY
)SQLDialect.MYSQL
SQLDialect.SQLITE
(but without ORDER BY
)It is emulated by the following dialects:
SQLDialect.DB2
: Using XMLAGG()
SQLDialect.ORACLE
: Using LISTAGG()
SQLDialect.POSTGRES
: Using STRING_AGG()
SQLDialect.SYBASE
: Using LIST()
groupConcat(Field)
and
GroupConcatSeparatorStep.separator(String)
instead.This is natively supported by
SQLDialect.AURORA_MYSQL
SQLDialect.H2
SQLDialect.HSQLDB
SQLDialect.MEMSQL
SQLDialect.MYSQL
SQLDialect.SQLITE
It is emulated by the following dialects:
SQLDialect.DB2
: Using XMLAGG()
SQLDialect.ORACLE
: Using LISTAGG()
SQLDialect.POSTGRES
: Using STRING_AGG()
SQLDialect.SYBASE
: Using LIST()
This is natively supported by
It is emulated by the following dialects:
SQLDialect.SYBASE
: Using LIST()
SQLDialect.POSTGRES
: Using STRING_AGG()
mode() within group (oder by [order clause])
ordered
aggregate function.rank(expr) within group (order by [order clause])
ordered-set aggregate function.rank(expr) within group (order by [order clause])
ordered-set aggregate function.dense_rank(expr) within group (order by [order clause])
ordered-set aggregate function.dense_rank(expr) within group (order by [order clause])
ordered-set aggregate function.percent_rank(expr) within group (order by [order clause])
ordered-set aggregate function.percent_rank(expr) within group (order by [order clause])
ordered-set aggregate function.cume_dist(expr) within group (order by [order clause])
ordered-set aggregate function.cume_dist(expr) within group (order by [order clause])
ordered-set aggregate function.percentile_cont([number]) within group (order by [column])
function.
While most dialects support this as an aggregate function,
SQLDialect.BIGQUERY
, SQLDialect.SQLSERVER
, and
SQLDialect.REDSHIFT
support only its window function variant.
percentile_cont([number]) within group (order by [column])
function.
While most dialects support this as an aggregate function,
SQLDialect.BIGQUERY
, SQLDialect.SQLSERVER
, and
SQLDialect.REDSHIFT
support only its window function variant.
percentile_disc([number]) within group (order by [column])
function.
While most dialects support this as an aggregate function,
SQLDialect.BIGQUERY
, SQLDialect.SQLSERVER
, and
SQLDialect.REDSHIFT
support only its window function variant.
percentile_disc([number]) within group (order by [column])
function.
While most dialects support this as an aggregate function,
SQLDialect.BIGQUERY
, SQLDialect.SQLSERVER
, and
SQLDialect.REDSHIFT
support only its window function variant.
WindowSpecification
with a PARTITION BY
clause.WindowSpecification
with a PARTITION BY
clause.WindowSpecification
with an ORDER BY
clause.WindowSpecification
with an ORDER BY
clause.WindowSpecification
with an ORDER BY
clause.WindowSpecification
with a ROWS
clause.WindowSpecification
with a ROWS
clause.WindowSpecification
with a ROWS
clause.WindowSpecification
with a ROWS
clause.WindowSpecification
with a ROWS
clause.WindowSpecification
with a ROWS
clause.WindowSpecification
with a ROWS
clause.WindowSpecification
with a ROWS
clause.WindowSpecification
with a ROWS
clause.WindowSpecification
with a ROWS
clause.WindowSpecification
with a RANGE
clause.WindowSpecification
with a RANGE
clause.WindowSpecification
with a RANGE
clause.WindowSpecification
with a RANGE
clause.WindowSpecification
with a RANGE
clause.WindowSpecification
with a RANGE
clause.WindowSpecification
with a RANGE
clause.WindowSpecification
with a RANGE
clause.WindowSpecification
with a RANGE
clause.WindowSpecification
with a RANGE
clause.WindowSpecification
with a GROUPS
clause.WindowSpecification
with a GROUPS
clause.WindowSpecification
with a GROUPS
clause.WindowSpecification
with a GROUPS
clause.WindowSpecification
with a GROUPS
clause.WindowSpecification
with a GROUPS
clause.WindowSpecification
with a GROUPS
clause.WindowSpecification
with a GROUPS
clause.WindowSpecification
with a GROUPS
clause.WindowSpecification
with a GROUPS
clause.row_number() over ([analytic clause])
function.
Newer versions of SQLDialect.DERBY
and SQLDialect.H2
also
support the ROW_NUMBER() OVER()
window function without any
window clause. See the respective docs for details.
SQLDialect.HSQLDB
can emulate this function using
ROWNUM()
rank() over ([analytic clause])
function.dense_rank() over ([analytic clause])
function.precent_rank() over ([analytic clause])
function.cume_dist() over ([analytic clause])
function.ntile([number]) over ([analytic clause])
function.ntile([number]) over ([analytic clause])
function.ratio_to_report([expression]) over ([analytic clause])
function.ratio_to_report([expression]) over ([analytic clause])
function.first_value(field) over ([analytic clause])
function.last_value(field) over ([analytic clause])
function.nth_value(field) over ([analytic clause])
function.nth_value(field) over ([analytic clause])
function.lead(field) over ([analytic clause])
function.lead(field, offset) over ([analytic clause])
function.lead(field, offset) over ([analytic clause])
function.lead(field, offset, defaultValue) over ([analytic clause])
function.lead(field, offset, defaultValue) over ([analytic clause])
function.lead(field, offset, defaultValue) over ([analytic clause])
function.lead(field, offset, defaultValue) over ([analytic clause])
function.lag(field) over ([analytic clause])
function.lag(field, offset) over ([analytic clause])
function.lag(field, offset) over ([analytic clause])
function.lag(field, offset, defaultValue) over ([analytic clause])
function.lag(field, offset, defaultValue) over ([analytic clause])
function.lag(field, offset, defaultValue) over ([analytic clause])
function.lag(field, offset, defaultValue) over ([analytic clause])
function.Object
/
SQLDataType.OTHER
) and no initial value.
Try to avoid this method when using any of these databases, as these
databases may have trouble inferring the type of the bind value. Use
typed named parameters instead, using param(Class)
or
param(DataType)
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
param(DataType)
.
Object
/
SQLDataType.OTHER
) and no initial value.
Try to avoid this method when using any of these databases, as these
databases may have trouble inferring the type of the bind value. Use
typed named parameters instead, using param(String, Class)
or
param(String, DataType)
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
param(String, DataType)
.
name
- The parameter nametype
- The type that is used for the parameter (a type that is
supported by SQLDataType
)Named parameters are useful for several use-cases:
JdbcTemplate
, which
supports named parameters. Use
DSLContext.renderNamedParams(QueryPart)
to render
parameter names in SQLAttachableQueryPart.getParam(String)
and AttachableQueryPart.getParams()
.val(Object)
to be used in Scala and Groovy, where
val
is a reserved keyword.
NOTE [#15286]: It is strongly recommended to pass only
instances of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
value(Object, DataType)
.
val(byte)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Byte)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(UByte)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(short)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Short)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(UShort)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(int)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Integer)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(UInteger)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(long)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Long)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(ULong)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(float)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Float)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(double)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Double)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(boolean)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Boolean)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(BigDecimal)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(BigInteger)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(byte[])
to be used in Scala and Groovy, where
val
is a reserved keyword.val(String)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Date)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Time)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Timestamp)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(LocalDate)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(LocalTime)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(LocalDateTime)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(OffsetTime)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(OffsetDateTime)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Instant)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(UUID)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(JSON)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(JSONB)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(XML)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Geography)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Geometry)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Object, Class)
to be used in Scala and Groovy,
where val
is a reserved keyword.
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
value(Object, DataType)
.
value
- The bind valuetype
- The type that is used for the bind value (a type that is
supported by SQLDataType
)val(Object, Field)
to be used in Scala and Groovy, where
val
is a reserved keyword.val(Object, DataType)
to be used in Scala and Groovy, where
val
is a reserved keyword.Field
.Condition
.QueryPart
.Statement
.
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
NOTE [#15286]: It is strongly recommended to pass only
instances of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
inline(Object, DataType)
.
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String)
, you can expect value
to
be properly escaped for SQL syntax correctness and SQL injection
prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
This is a convenience method for inline(Object)
, returning
Field<String>
, rather than
Field<Character>
This is a convenience method for inline(Object)
, returning
Field<String>
, rather than
Field<Character>
This is a convenience method for inline(Object)
, returning
Field<String>
, rather than
Field<CharSequence>
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String, Class)
, you can expect
value
to be properly escaped for SQL syntax correctness and
SQL injection prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
inline(Object, DataType)
.
value
- The inline valuetype
- The data type to enforce upon the value (a type that is
supported by SQLDataType
)
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String, DataType)
, you can expect
value
to be properly escaped for SQL syntax correctness and
SQL injection prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
The resulting bind value is always inlined, regardless of the
Settings.getStatementType()
property of the rendering factory.
Unlike with field(String, DataType)
, you can expect
value
to be properly escaped for SQL syntax correctness and
SQL injection prevention. For example:
inline("abc'def")
renders 'abc''def'
field("abc'def")
renders abc'def
jOOQ tries to derive the RDBMS DataType
from the provided Java
type <T>
. This may not always be accurate, which can
lead to problems in some strongly typed RDMBS, especially when value is
null
. These databases are namely:
If you need more type-safety, please use val(Object, DataType)
instead, and provide the precise RDMBS-specific data type, that is
needed.
NOTE [#15286]: It is strongly recommended to pass only
instances of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
val(Object, DataType)
.
T
- The generic value typevalue
- The constant value
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
val(Object, DataType)
.
T
- The generic value typevalue
- The constant valuetype
- The data type to enforce upon the value (a type that is
supported by SQLDataType
)T
- The generic value typevalue
- The constant valuefield
- The field whose data type to enforce upon the value
This will try to bind value
as type
in a
PreparedStatement
. If value
and
type
are not compatible, jOOQ will first try to convert and
then to cast value
to type
.
T
- The generic value typevalue
- The constant valuetype
- The data type to enforce upon the valueRecordType
of an arbitrary degree.RecordType
of an arbitrary degree.RecordType
of degree 1
.RecordType
of degree 2
.RecordType
of degree 3
.RecordType
of degree 4
.RecordType
of degree 5
.RecordType
of degree 6
.RecordType
of degree 7
.RecordType
of degree 8
.RecordType
of degree 9
.RecordType
of degree 10
.RecordType
of degree 11
.RecordType
of degree 12
.RecordType
of degree 13
.RecordType
of degree 14
.RecordType
of degree 15
.RecordType
of degree 16
.RecordType
of degree 17
.RecordType
of degree 18
.RecordType
of degree 19
.RecordType
of degree 20
.RecordType
of degree 21
.RecordType
of degree 22
.1
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
2
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
3
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
4
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
5
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
6
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
7
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
8
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
9
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
10
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
11
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
12
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
13
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
14
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
15
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
16
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
17
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
18
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
19
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
20
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
21
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
22
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
N > 22
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
1
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
2
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
3
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
4
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
5
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
6
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
7
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
8
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
9
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
10
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
11
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
12
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
13
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
14
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
15
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
16
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
17
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
18
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
19
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
20
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
21
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
22
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
N > 22
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
N > 22
.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.
VALUES()
expression of arbitrary degree.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2),
(val2_1, val2_2),
(val3_1, val3_2)
AS "v"("c1" , "c2" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 1
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1),
(val2_1),
(val3_1)
AS "v"("c1" )
-- Using UNION ALL
SELECT val1_1 AS "c1") UNION ALL
SELECT val1_1 AS "c1") UNION ALL
SELECT val1_1 AS "c1")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 2
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2),
(val2_1, val2_2),
(val3_1, val3_2)
AS "v"("c1" , "c2" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 3
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3),
(val2_1, val2_2, val2_3),
(val3_1, val3_2, val3_3)
AS "v"("c1" , "c2" , "c3" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 4
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4),
(val2_1, val2_2, val2_3, val2_4),
(val3_1, val3_2, val3_3, val3_4)
AS "v"("c1" , "c2" , "c3" , "c4" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 5
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5),
(val2_1, val2_2, val2_3, val2_4, val2_5),
(val3_1, val3_2, val3_3, val3_4, val3_5)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 6
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 7
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 8
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 9
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 10
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 11
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 12
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 13
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 14
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 15
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 16
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 17
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 18
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" , "c18" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 19
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" , "c18" , "c19" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 20
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19, val1_20),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19, val2_20),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19, val3_20)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" , "c18" , "c19" , "c20" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 21
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19, val1_20, val1_21),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19, val2_20, val2_21),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19, val3_20, val3_21)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" , "c18" , "c19" , "c20" , "c21" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
VALUES()
expression of degree 22
.
The VALUES()
constructor is a tool supported by some
databases to allow for constructing tables from constant values.
If a database doesn't support the VALUES()
constructor, it
can be emulated using SELECT … UNION ALL …
. The following
expressions are equivalent:
-- Using VALUES() constructor
VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19, val1_20, val1_21, val1_22),
(val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19, val2_20, val2_21, val2_22),
(val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19, val3_20, val3_21, val3_22)
AS "v"("c1" , "c2" , "c3" , "c4" , "c5" , "c6" , "c7" , "c8" , "c9" , "c10" , "c11" , "c12" , "c13" , "c14" , "c15" , "c16" , "c17" , "c18" , "c19" , "c20" , "c21" , "c22" )
-- Using UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21", val1_22 AS "c22") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21", val1_22 AS "c22") UNION ALL
SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21", val1_22 AS "c22")
Use Table.as(String, String...)
to rename the resulting table and
its columns.
*
) to be used in SELECT
clauses.
When using an asterisk, jOOQ will let the database server define the order of columns, as well as which columns are included in the result set. If using jOOQ with generated code, this may conflict with the column set and its ordering as defined at code generation time, meaning columns may be in a different order, there may be fewer or more columns than expected. It is usually better to list columns explicitly.
0
literal.
This is useful for mathematical functions or for
EXISTS (SELECT 0 …)
or PARTITION BY 0
clauses
and similar constructs. The 0
literal will not generate a
bind variable.
0
literal as a Field
1
literal.
This is useful for mathematical functions or for
EXISTS (SELECT 1 …)
or PARTITION BY 1
clauses
and similar constructs. The 1
literal will not generate a
bind variable.
1
literal as a Field
2
literal.
This is useful for mathematical functions. The 1
literal
will not generate a bind variable.
2
literal as a Field
DSLContext
's underlying
SQLDialect
and a given Java type.
NOTE [#15286]: It is strongly recommended to pass only
Class
references of types supported by jOOQ internally, i.e.
types from SQLDataType
. If you're using any custom data types by
means of a Converter
or Binding
, it's better to pass that
converted DataType
reference explicitly to
param(DataType)
.
T
- The generic typetype
- The Java type. This must be a type supported by
SQLDataType
.DSL
's underlying default data type.