Uses of Interface
org.jooq.SQL

Packages that use SQL

Package	Description
org.jooq	This package contains jOOQ's public API.
org.jooq.impl	This package contains jOOQ's implementation classes.

Uses of SQL in org.jooq

Methods in org.jooq with parameters of type SQL

Modifier and Type	Method	Description
@NotNull Condition	Condition.and(SQL sql)	Combine this condition with another one using the Operator.AND operator.
@NotNull DeleteConditionStep<R>	DeleteConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator
@NotNull DivideByOnConditionStep	DivideByOnConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator.
@NotNull InsertOnConflictConditionStep<R>	InsertOnConflictConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
@NotNull MergeOnConditionStep<R>	MergeOnConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
@NotNull SelectConditionStep<R>	SelectConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
@NotNull SelectConnectByAfterStartWithConditionStep<R>	SelectConnectByAfterStartWithConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
@NotNull SelectConnectByConditionStep<R>	SelectConnectByConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
@NotNull SelectHavingConditionStep<R>	SelectHavingConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
@NotNull SelectOnConditionStep<R>	SelectOnConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
@NotNull SelectQualifyConditionStep<R>	SelectQualifyConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
@NotNull TableOnConditionStep<R>	TableOnConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator.
@NotNull UpdateConditionStep<R>	UpdateConditionStep.and(SQL sql)	Combine the currently assembled conditions with another one using the Operator.AND operator
@NotNull CreateViewFinalStep	CreateViewAsStep.as(SQL sql)	Add an AS clause to the CREATE VIEW statement.
@NotNull SelectConnectByAfterStartWithConditionStep<R>	SelectConnectByAfterStartWithStep.connectBy(SQL sql)	Add an Oracle-specific CONNECT BY clause to the query
@NotNull SelectConnectByConditionStep<R>	SelectConnectByStep.connectBy(SQL sql)	Add an Oracle-specific CONNECT BY clause to the query.
@NotNull SelectConnectByAfterStartWithConditionStep<R>	SelectConnectByAfterStartWithStep.connectByNoCycle(SQL sql)	Add an Oracle-specific CONNECT BY NOCYCLE clause to the query
@NotNull SelectConnectByConditionStep<R>	SelectConnectByStep.connectByNoCycle(SQL sql)	Add an Oracle-specific CONNECT BY NOCYCLE clause to the query
@NotNull SelectJoinStep<R>	SelectJoinStep.crossApply(SQL sql)	CROSS APPLY a table to this table.
@NotNull Table<Record>	Table.crossApply(SQL sql)	CROSS APPLY a table to this table.
@NotNull SelectJoinStep<R>	SelectJoinStep.crossJoin(SQL sql)	Convenience method to CROSS JOIN a table to the last table added to the FROM clause using Table.crossJoin(String)
@NotNull Table<Record>	Table.crossJoin(SQL sql)	CROSS JOIN a table to this table.
int	DSLContext.execute(SQL sql)	Execute a query holding plain SQL.
@NotNull Result<Record>	DSLContext.fetch(SQL sql)	Execute a new query holding plain SQL.
@NotNull CompletionStage<Result<Record>>	DSLContext.fetchAsync(Executor executor, SQL sql)	Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.
@NotNull CompletionStage<Result<Record>>	DSLContext.fetchAsync(SQL sql)	Fetch results in a new CompletionStage.
@NotNull Cursor<Record>	DSLContext.fetchLazy(SQL sql)	Execute a new query holding plain SQL and "lazily" return the generated result.
@NotNull Results	DSLContext.fetchMany(SQL sql)	Execute a new query holding plain SQL, possibly returning several result sets.
@Nullable Record	DSLContext.fetchOne(SQL sql)	Execute a new query holding plain SQL.
@NotNull Optional<Record>	DSLContext.fetchOptional(SQL sql)	Execute a new query holding plain SQL.
@NotNull Optional<?>	DSLContext.fetchOptionalValue(SQL sql)	Execute a new query holding plain SQL.
@NotNull Record	DSLContext.fetchSingle(SQL sql)	Execute a new query holding plain SQL.
@NotNull Stream<Record>	DSLContext.fetchStream(SQL sql)	Execute a new query holding plain SQL and "lazily" return the generated result.
@Nullable Object	DSLContext.fetchValue(SQL sql)	Execute a new query holding plain SQL.
@NotNull List<?>	DSLContext.fetchValues(SQL sql)	Execute a new query holding plain SQL.
@NotNull WindowBeforeOverStep<T>	AggregateFilterStep.filterWhere(SQL sql)	Add a FILTER clause to the aggregate function.
@NotNull SelectJoinStep<R>	SelectFromStep.from(SQL sql)	Add a FROM clause to the query.
@NotNull UpdateWhereStep<R>	UpdateFromStep.from(SQL sql)	Add a FROM clause to the query.
@NotNull SelectOnStep<R>	SelectJoinStep.fullJoin(SQL sql)	Convenience method to FULL OUTER JOIN a table to the last table added to the FROM clause using Table.fullOuterJoin(String).
@NotNull TablePartitionByStep<Record>	Table.fullJoin(SQL sql)	FULL OUTER JOIN a table to this table.
@NotNull TablePartitionByStep<Record>	TableOuterJoinStep.fullJoin(SQL sql)	FULL OUTER JOIN a table to this table.
@NotNull SelectOnStep<R>	SelectJoinStep.fullOuterJoin(SQL sql)	Convenience method to FULL OUTER JOIN a table to the last table added to the FROM clause using Table.fullOuterJoin(String)
@NotNull TablePartitionByStep<Record>	Table.fullOuterJoin(SQL sql)	FULL OUTER JOIN a table to this table.
@NotNull TablePartitionByStep<Record>	TableOuterJoinStep.fullOuterJoin(SQL sql)	FULL OUTER JOIN a table to this table.
@NotNull SelectHavingConditionStep<R>	SelectHavingStep.having(SQL sql)	Add a HAVING clause to the query.
@NotNull SelectOnStep<R>	SelectJoinStep.innerJoin(SQL sql)	Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(String).
@NotNull TableOnStep<Record>	Table.innerJoin(SQL sql)	INNER JOIN a table to this table.
@NotNull SelectOnStep<R>	SelectJoinStep.join(SQL sql)	Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(String).
@NotNull TableOnStep<Record>	Table.join(SQL sql)	INNER JOIN a table to this table.
@NotNull SelectJoinPartitionByStep<R>	SelectJoinStep.leftJoin(SQL sql)	Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(String).
@NotNull TablePartitionByStep<Record>	Table.leftJoin(SQL sql)	LEFT OUTER JOIN a table to this table.
@NotNull TablePartitionByStep<Record>	TableOuterJoinStep.leftJoin(SQL sql)	LEFT OUTER JOIN a table to this table.
@NotNull SelectJoinPartitionByStep<R>	SelectJoinStep.leftOuterJoin(SQL sql)	Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(String)
@NotNull TablePartitionByStep<Record>	Table.leftOuterJoin(SQL sql)	LEFT OUTER JOIN a table to this table.
@NotNull TablePartitionByStep<Record>	TableOuterJoinStep.leftOuterJoin(SQL sql)	LEFT OUTER JOIN a table to this table.
@NotNull SelectJoinStep<R>	SelectJoinStep.naturalFullOuterJoin(SQL sql)	Convenience method to NATURAL FULL OUTER JOIN a table to the last table added to the FROM clause using Table.naturalFullOuterJoin(String)
@NotNull Table<Record>	Table.naturalFullOuterJoin(SQL sql)	NATURAL FULL OUTER JOIN a table to this table.
@NotNull SelectJoinStep<R>	SelectJoinStep.naturalJoin(SQL sql)	Convenience method to NATURAL JOIN a table to the last table added to the FROM clause using Table.naturalJoin(String)
@NotNull Table<Record>	Table.naturalJoin(SQL sql)	NATURAL JOIN a table to this table.
@NotNull SelectJoinStep<R>	SelectJoinStep.naturalLeftOuterJoin(SQL sql)	Convenience method to NATURAL LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.naturalLeftOuterJoin(String)
@NotNull Table<Record>	Table.naturalLeftOuterJoin(SQL sql)	NATURAL LEFT OUTER JOIN a table to this table.
@NotNull SelectJoinStep<R>	SelectJoinStep.naturalRightOuterJoin(SQL sql)	Convenience method to NATURAL RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.naturalRightOuterJoin(String)
@NotNull Table<Record>	Table.naturalRightOuterJoin(SQL sql)	NATURAL RIGHT OUTER JOIN a table to this table.
@NotNull DivideByOnConditionStep	DivideByOnStep.on(SQL sql)	Add a division condition to the DIVIDE BY clause
@NotNull MergeOnConditionStep<R>	MergeOnStep.on(SQL sql)	Provide join conditions and proceed to the next step
@NotNull SelectOnConditionStep<R>	SelectOnStep.on(SQL sql)	Add an ON clause to the previous JOIN.
@NotNull TableOnConditionStep<R>	TableOnStep.on(SQL sql)	Add an ON clause to the JOIN.
@NotNull Condition	Condition.or(SQL sql)	Combine this condition with another one using the Operator.OR operator.
@NotNull DeleteConditionStep<R>	DeleteConditionStep.or(SQL sql)	Combine the currently assembled conditions with another one using the Operator.OR operator
@NotNull DivideByOnConditionStep	DivideByOnConditionStep.or(SQL sql)	Combine the currently assembled conditions with another one using the Operator.OR operator.
@NotNull InsertOnConflictConditionStep<R>	InsertOnConflictConditionStep.or(SQL sql)	Combine the currently assembled conditions with another one using the Operator.OR operator and proceed to the next step.
@NotNull MergeOnConditionStep<R>	MergeOnConditionStep.or(SQL sql)	Combine the currently assembled conditions with another one using the Operator.OR operator and proceed to the next step.
@NotNull SelectConditionStep<R>	SelectConditionStep.or(SQL sql)	Combine the currently assembled conditions with another one using the Operator.OR operator and proceed to the next step.
@NotNull SelectHavingConditionStep<R>	SelectHavingConditionStep.or(SQL sql)	Combine the currently assembled conditions with another one using the Operator.OR operator and proceed to the next step.
@NotNull SelectOnConditionStep<R>	SelectOnConditionStep.or(SQL sql)	Combine the currently assembled conditions with another one using the Operator.OR operator and proceed to the next step.
@NotNull SelectQualifyConditionStep<R>	SelectQualifyConditionStep.or(SQL sql)	Combine the currently assembled conditions with another one using the Operator.OR operator and proceed to the next step.
@NotNull TableOnConditionStep<R>	TableOnConditionStep.or(SQL sql)	Combine the currently assembled conditions with another one using the Operator.OR operator.
@NotNull UpdateConditionStep<R>	UpdateConditionStep.or(SQL sql)	Combine the currently assembled conditions with another one using the Operator.OR operator
@NotNull SelectJoinStep<R>	SelectJoinStep.outerApply(SQL sql)	OUTER APPLY a table to this table.
@NotNull Table<Record>	Table.outerApply(SQL sql)	OUTER APPLY a table to this table.
@NotNull SelectQualifyConditionStep<R>	SelectQualifyStep.qualify(SQL sql)	Add a QUALIFY clause to the query.
@NotNull RowCountQuery	DSLContext.query(SQL sql)	Create a new query holding plain SQL.
@NotNull ResultQuery<Record>	DSLContext.resultQuery(SQL sql)	Create a new query holding plain SQL.
@NotNull SelectJoinPartitionByStep<R>	SelectJoinStep.rightJoin(SQL sql)	Convenience method to RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.rightOuterJoin(String).
@NotNull TablePartitionByStep<Record>	Table.rightJoin(SQL sql)	RIGHT OUTER JOIN a table to this table.
@NotNull TablePartitionByStep<Record>	TableOuterJoinStep.rightJoin(SQL sql)	RIGHT OUTER JOIN a table to this table.
@NotNull SelectJoinPartitionByStep<R>	SelectJoinStep.rightOuterJoin(SQL sql)	Convenience method to RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.rightOuterJoin(String)
@NotNull TablePartitionByStep<Record>	Table.rightOuterJoin(SQL sql)	RIGHT OUTER JOIN a table to this table.
@NotNull TablePartitionByStep<Record>	TableOuterJoinStep.rightOuterJoin(SQL sql)	RIGHT OUTER JOIN a table to this table.
@NotNull SelectWhereStep<Record>	DSLContext.selectFrom(SQL sql)	Create a new DSL select statement, projecting *.
@NotNull SelectWhereStep<Record>	WithStep.selectFrom(SQL sql)	Create a new DSL select statement, projecting *.
@NotNull SelectConnectByAfterStartWithStep<R>	SelectConnectByStep.startWith(SQL sql)	Add an Oracle-specific START WITH clause to the query's CONNECT BY clause.
@NotNull SelectGroupByStep<R>	SelectStartWithStep.startWith(SQL sql)	Add an Oracle-specific START WITH clause to the query's CONNECT BY clause.
@NotNull CreateTableFinalStep	CreateTableStorageStep.storage(SQL storage)	Add the STORAGE clause to the CREATE TABLE statement.
@NotNull SelectOnStep<R>	SelectJoinStep.straightJoin(SQL sql)	STRAIGHT_JOIN a table to this table.
@NotNull TableOnStep<Record>	Table.straightJoin(SQL sql)	STRAIGHT_JOIN a table to this table.
@NotNull DeleteWhereStep<R>	DeleteUsingStep.using(SQL sql)	Add a USING clause to the query.
@NotNull CreateTriggerActionStep	CreateTriggerWhenStep.when(SQL when)	Add the WHEN clause to the CREATE TRIGGER statement.
@NotNull MergeMatchedThenStep<R>	MergeMatchedStep.whenMatchedAnd(SQL sql)	Add the WHEN MATCHED AND clause to the MERGE statement.
@NotNull CreateIndexFinalStep	CreateIndexWhereStep.where(SQL where)	Add the WHERE clause to the CREATE INDEX statement.
@NotNull DeleteConditionStep<R>	DeleteWhereStep.where(SQL sql)	Add conditions to the query.
@NotNull InsertOnConflictDoUpdateStep<R>	InsertOnConflictWhereIndexPredicateStep.where(SQL sql)	Add a WHERE clause to supply an index predicate to the INSERT statement's ON CONFLICT … clause.
@NotNull InsertOnConflictConditionStep<R>	InsertOnConflictWhereStep.where(SQL sql)	Add a WHERE clause to the INSERT statement's ON DUPLICATE KEY UPDATE or ON CONFLICT … DO UPDATE clause.
@NotNull SelectConditionStep<R>	SelectWhereStep.where(SQL sql)	Add a WHERE clause to the query.
@NotNull Table<R>	Table.where(SQL sql)	Add a WHERE clause to the table.
@NotNull UpdateConditionStep<R>	UpdateWhereStep.where(SQL sql)	Add conditions to the query
@NotNull Table<R>	Table.with(SQL hint)	Specify a SQL Server style table hint for query optimisation.
@NotNull Condition	Condition.xor(SQL sql)	Combine this condition with another one using the Operator.XOR operator.

Uses of SQL in org.jooq.impl

Methods in org.jooq.impl that return SQL

Modifier and Type	Method	Description
@Nullable SQL	QOM.CreateTable.$storage()
static @NotNull SQL	DSL.raw(String sql)	A custom SQL clause that can render arbitrary expressions.
static @NotNull SQL	DSL.sql(String sql)	A custom SQL clause that can render arbitrary expressions.
static @NotNull SQL	DSL.sql(String sql, Object... bindings)	A custom SQL clause that can render arbitrary expressions.
static @NotNull SQL	DSL.sql(String sql, QueryPart... parts)	A custom SQL clause that can render arbitrary expressions.

Methods in org.jooq.impl with parameters of type SQL

Modifier and Type	Method	Description
@NotNull QOM.CreateTable	QOM.CreateTable.$storage(SQL storage)
static @NotNull Condition	DSL.condition(SQL sql)	Create a new condition holding plain SQL.
int	DefaultDSLContext.execute(SQL sql)
Result<Record>	DefaultDSLContext.fetch(SQL sql)
CompletionStage<Result<Record>>	DefaultDSLContext.fetchAsync(Executor executor, SQL sql)
CompletionStage<Result<Record>>	DefaultDSLContext.fetchAsync(SQL sql)
Cursor<Record>	DefaultDSLContext.fetchLazy(SQL sql)
Results	DefaultDSLContext.fetchMany(SQL sql)
Record	DefaultDSLContext.fetchOne(SQL sql)
Optional<Record>	DefaultDSLContext.fetchOptional(SQL sql)
Optional<?>	DefaultDSLContext.fetchOptionalValue(SQL sql)
Record	DefaultDSLContext.fetchSingle(SQL sql)
Stream<Record>	DefaultDSLContext.fetchStream(SQL sql)
Object	DefaultDSLContext.fetchValue(SQL sql)
List<?>	DefaultDSLContext.fetchValues(SQL sql)
static @NotNull Field<Object>	DSL.field(SQL sql)	Create a "plain SQL" field.
static <T> @NotNull Field<T>	DSL.field(SQL sql, Class<T> type)	Create a "plain SQL" field.
static <T> @NotNull Field<T>	DSL.field(SQL sql, DataType<T> type)	Create a "plain SQL" field.
RowCountQuery	DefaultDSLContext.query(SQL sql)
static @NotNull RowCountQuery	DSL.query(SQL sql)	Create a new query holding plain SQL.
ResultQuery<Record>	DefaultDSLContext.resultQuery(SQL sql)
static @NotNull ResultQuery<Record>	DSL.resultQuery(SQL sql)	Create a new query holding plain SQL.
SelectWhereStep<Record>	DefaultDSLContext.selectFrom(SQL sql)
static @NotNull SelectWhereStep<Record>	DSL.selectFrom(SQL sql)	Create a new DSL select statement, projecting *.
static @NotNull Statement	DSL.statement(SQL sql)	A custom procedural fragment that can render arbitrary statements.
static @NotNull Table<Record>	DSL.table(SQL sql)	A custom SQL clause that can render arbitrary table expressions.