Uses of Interface org.jooq.SQL (jOOQ 3.10.8 API)

Packages that use SQL
Package Description

org.jooq
The org.jooq package contains jOOQ's public API.

org.jooq.impl
The org.jooq.impl package contains jOOQ's implementation classes.

Packages that use SQL
Package	Description
org.jooq	The `org.jooq` package contains jOOQ's public API.
org.jooq.impl	The `org.jooq.impl` 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 and Description
`UpdateConditionStep<R>`	UpdateConditionStep.`and(SQL sql)` Combine the currently assembled conditions with another one using the `Operator.AND` operator NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`TableOnConditionStep<R>`	TableOnConditionStep.`and(SQL sql)` Combine the currently assembled conditions with another one using the `Operator.AND` operator.
`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.
`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.
`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.
`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.
`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.
`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.
`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.
`DivideByOnConditionStep`	DivideByOnConditionStep.`and(SQL sql)` Combine the currently assembled conditions with another one using the `Operator.AND` operator.
`DeleteConditionStep<R>`	DeleteConditionStep.`and(SQL sql)` Combine the currently assembled conditions with another one using the `Operator.AND` operator NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`Condition`	Condition.`and(SQL sql)` Combine this condition with another one using the `Operator.AND` operator.
`SelectConnectByConditionStep<R>`	SelectConnectByStep.`connectBy(SQL sql)` Add an Oracle-specific `CONNECT BY` clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectConnectByAfterStartWithConditionStep<R>`	SelectConnectByAfterStartWithStep.`connectBy(SQL sql)` Add an Oracle-specific `CONNECT BY` clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectConnectByConditionStep<R>`	SelectConnectByStep.`connectByNoCycle(SQL sql)` Add an Oracle-specific `CONNECT BY NOCYCLE` clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectConnectByAfterStartWithConditionStep<R>`	SelectConnectByAfterStartWithStep.`connectByNoCycle(SQL sql)` Add an Oracle-specific `CONNECT BY NOCYCLE` clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`Table<Record>`	Table.`crossApply(SQL sql)` `CROSS APPLY` a table to this table.
`SelectJoinStep<R>`	SelectJoinStep.`crossApply(SQL sql)` `CROSS APPLY` a table to this table.
`Table<Record>`	Table.`crossJoin(SQL sql)` `CROSS JOIN` a table to this table.
`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)` If this syntax is unavailable, it is emulated with a regular `INNER JOIN`.
`int`	DSLContext.`execute(SQL sql)` Execute a query holding plain SQL.
`Result<Record>`	DSLContext.`fetch(SQL sql)` Execute a new query holding plain SQL.
`java.util.concurrent.CompletionStage<Result<Record>>`	DSLContext.`fetchAsync(java.util.concurrent.Executor executor, SQL sql)` Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`java.util.concurrent.CompletionStage<Result<Record>>`	DSLContext.`fetchAsync(SQL sql)` Fetch results in a new `CompletionStage`.
`Cursor<Record>`	DSLContext.`fetchLazy(SQL sql)` Execute a new query holding plain SQL and "lazily" return the generated result.
`Results`	DSLContext.`fetchMany(SQL sql)` Execute a new query holding plain SQL, possibly returning several result sets.
`Record`	DSLContext.`fetchOne(SQL sql)` Execute a new query holding plain SQL.
`java.util.Optional<Record>`	DSLContext.`fetchOptional(SQL sql)` Execute a new query holding plain SQL.
`java.util.Optional<?>`	DSLContext.`fetchOptionalValue(SQL sql)` Execute a new query holding plain SQL.
`Record`	DSLContext.`fetchSingle(SQL sql)` Execute a new query holding plain SQL.
`java.util.stream.Stream<Record>`	DSLContext.`fetchStream(SQL sql)` Execute a new query holding plain SQL and "lazily" return the generated result.
`java.lang.Object`	DSLContext.`fetchValue(SQL sql)` Execute a new query holding plain SQL.
`java.util.List<?>`	DSLContext.`fetchValues(SQL sql)` Execute a new query holding plain SQL.
`WindowBeforeOverStep<T>`	AggregateFilterStep.`filterWhere(SQL sql)` Add a `FILTER clause` to the aggregate function.
`UpdateWhereStep<R>`	UpdateFromStep.`from(SQL sql)` Add a `FROM` clause to the query.
`SelectJoinStep<R>`	SelectFromStep.`from(SQL sql)` Add a `FROM` clause to the query.
`TableOnStep<Record>`	Table.`fullJoin(SQL sql)` `FULL OUTER JOIN` a table to this table.
`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)`.
`TableOnStep<Record>`	Table.`fullOuterJoin(SQL sql)` `FULL OUTER JOIN` a table to this table.
`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)` This is only possible where the underlying RDBMS supports it NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectHavingConditionStep<R>`	SelectHavingStep.`having(SQL sql)` Add a `HAVING` clause to the query.
`TableOnStep<Record>`	Table.`innerJoin(SQL sql)` `INNER JOIN` a table to this table.
`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)`.
`TableOnStep<Record>`	Table.`join(SQL sql)` `INNER JOIN` a table to this table.
`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)`.
`TableOnStep<Record>`	TableOuterJoinStep.`leftJoin(SQL sql)` `LEFT OUTER JOIN` a table to this table.
`TablePartitionByStep<Record>`	Table.`leftJoin(SQL sql)` `LEFT OUTER JOIN` a table to this table.
`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)`.
`TableOnStep<Record>`	TableOuterJoinStep.`leftOuterJoin(SQL sql)` `LEFT OUTER JOIN` a table to this table.
`TablePartitionByStep<Record>`	Table.`leftOuterJoin(SQL sql)` `LEFT OUTER JOIN` a table to this table.
`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)` NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`Table<Record>`	Table.`naturalJoin(SQL sql)` `NATURAL JOIN` a table to this table.
`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)` Natural joins are supported by most RDBMS.
`Table<Record>`	Table.`naturalLeftOuterJoin(SQL sql)` `NATURAL LEFT OUTER JOIN` a table to this table.
`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)` Natural joins are supported by most RDBMS.
`Table<Record>`	Table.`naturalRightOuterJoin(SQL sql)` `NATURAL RIGHT OUTER JOIN` a table to this table.
`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)` Natural joins are supported by most RDBMS.
`TableOnConditionStep<R>`	TableOnStep.`on(SQL sql)` Add an `ON` clause to the `JOIN`.
`SelectOnConditionStep<R>`	SelectOnStep.`on(SQL sql)` Add an `ON` clause to the previous `JOIN`.
`MergeOnConditionStep<R>`	MergeOnStep.`on(SQL sql)` Provide join conditions and proceed to the next step NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`DivideByOnConditionStep`	DivideByOnStep.`on(SQL sql)` Add a division condition to the `DIVIDE BY` clause NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`UpdateConditionStep<R>`	UpdateConditionStep.`or(SQL sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`TableOnConditionStep<R>`	TableOnConditionStep.`or(SQL sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator.
`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.
`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.
`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.
`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.
`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.
`DivideByOnConditionStep`	DivideByOnConditionStep.`or(SQL sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator.
`DeleteConditionStep<R>`	DeleteConditionStep.`or(SQL sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`Condition`	Condition.`or(SQL sql)` Combine this condition with another one using the `Operator.OR` operator.
`Table<Record>`	Table.`outerApply(SQL sql)` `OUTER APPLY` a table to this table.
`SelectJoinStep<R>`	SelectJoinStep.`outerApply(SQL sql)` `OUTER APPLY` a table to this table.
`Query`	DSLContext.`query(SQL sql)` Create a new query holding plain SQL.
`ResultQuery<Record>`	DSLContext.`resultQuery(SQL sql)` Create a new query holding plain SQL.
`TableOnStep<Record>`	TableOuterJoinStep.`rightJoin(SQL sql)` `RIGHT OUTER JOIN` a table to this table.
`TablePartitionByStep<Record>`	Table.`rightJoin(SQL sql)` `RIGHT OUTER JOIN` a table to this table.
`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)`.
`TableOnStep<Record>`	TableOuterJoinStep.`rightOuterJoin(SQL sql)` `RIGHT OUTER JOIN` a table to this table.
`TablePartitionByStep<Record>`	Table.`rightOuterJoin(SQL sql)` `RIGHT OUTER JOIN` a table to this table.
`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)` This is only possible where the underlying RDBMS supports it NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectGroupByStep<R>`	SelectStartWithStep.`startWith(SQL sql)` Add an Oracle-specific `START WITH` clause to the query's `CONNECT BY` clause.
`SelectConnectByAfterStartWithStep<R>`	SelectConnectByStep.`startWith(SQL sql)` Add an Oracle-specific `START WITH` clause to the query's `CONNECT BY` clause.
`TableOnStep<Record>`	Table.`straightJoin(SQL sql)` `STRAIGHT_JOIN` a table to this table.
`SelectOnStep<R>`	SelectJoinStep.`straightJoin(SQL sql)` `STRAIGHT_JOIN` a table to this table.
`UpdateConditionStep<R>`	UpdateWhereStep.`where(SQL sql)` Add conditions to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectConditionStep<R>`	SelectWhereStep.`where(SQL sql)` Add a `WHERE` clause to the query.
`InsertReturningStep<R>`	InsertOnConflictWhereStep.`where(SQL sql)` Add a `WHERE` clause to the query.
`DeleteConditionStep<R>`	DeleteWhereStep.`where(SQL sql)` Add conditions to the query.
`CreateIndexFinalStep`	CreateIndexWhereStep.`where(SQL sql)` Add a `WHERE` clause to create a partial index.

Uses of SQL in org.jooq.impl

Methods in org.jooq.impl that return SQL
Modifier and Type	Method and Description
`static SQL`	DSL.`sql(java.lang.String sql)` A custom SQL clause that can render arbitrary expressions.
`static SQL`	DSL.`sql(java.lang.String sql, java.lang.Object... bindings)` A custom SQL clause that can render arbitrary expressions.
`static SQL`	DSL.`sql(java.lang.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 and Description
`static Condition`	DSL.`condition(SQL sql)` Create a new condition holding plain SQL.
`int`	DefaultDSLContext.`execute(SQL sql)`
`Result<Record>`	DefaultDSLContext.`fetch(SQL sql)`
`java.util.concurrent.CompletionStage<Result<Record>>`	DefaultDSLContext.`fetchAsync(java.util.concurrent.Executor executor, SQL sql)`
`java.util.concurrent.CompletionStage<Result<Record>>`	DefaultDSLContext.`fetchAsync(SQL sql)`
`Cursor<Record>`	DefaultDSLContext.`fetchLazy(SQL sql)`
`Results`	DefaultDSLContext.`fetchMany(SQL sql)`
`Record`	DefaultDSLContext.`fetchOne(SQL sql)`
`java.util.Optional<Record>`	DefaultDSLContext.`fetchOptional(SQL sql)`
`java.util.Optional<?>`	DefaultDSLContext.`fetchOptionalValue(SQL sql)`
`Record`	DefaultDSLContext.`fetchSingle(SQL sql)`
`java.util.stream.Stream<Record>`	DefaultDSLContext.`fetchStream(SQL sql)`
`java.lang.Object`	DefaultDSLContext.`fetchValue(SQL sql)`
`java.util.List<?>`	DefaultDSLContext.`fetchValues(SQL sql)`
`static Field<java.lang.Object>`	DSL.`field(SQL sql)` Create a "plain SQL" field.
`static <T> Field<T>`	DSL.`field(SQL sql, java.lang.Class<T> type)` Create a "plain SQL" field.
`static <T> Field<T>`	DSL.`field(SQL sql, DataType<T> type)` Create a "plain SQL" field.
`static Query`	DSL.`query(SQL sql)` Create a new query holding plain SQL.
`Query`	DefaultDSLContext.`query(SQL sql)`
`static ResultQuery<Record>`	DSL.`resultQuery(SQL sql)` Create a new query holding plain SQL.
`ResultQuery<Record>`	DefaultDSLContext.`resultQuery(SQL sql)`
`static Table<Record>`	DSL.`table(SQL sql)` A custom SQL clause that can render arbitrary table expressions.

Uses of Interfaceorg.jooq.SQL

Uses of SQL in org.jooq

Uses of SQL in org.jooq.impl

Uses of Interface
org.jooq.SQL