Uses of Interface
org.jooq.QueryPart

Packages that use QueryPart

org.jooq
org.jooq.impl

Uses of QueryPart in org.jooq

Subinterfaces of QueryPart in org.jooq

interface	AggregateFunction<T> An aggregate function is a special field that is usually used in a GROUP BY context.
interface	AliasProvider<Z extends AliasProvider<Z>> A QueryPart that can create an aliased QueryPart of itself
interface	CaseConditionStep<T> The final step in creating a case statement of the type CASE WHEN x < 1 THEN 'one' WHEN x >= 2 THEN 'two' ELSE 'three' END
interface	CaseWhenStep<V,T> The final step in creating a case statement of the type CASE x WHEN 1 THEN 'one' WHEN 2 THEN 'two' ELSE 'three' END
interface	Condition A condition to be used in a query's where part
interface	Delete<R extends Record> A Query that can delete data in the database.
interface	DeleteConditionStep<R extends Record> This type is used for the Delete's DSL API.
interface	DeleteFinalStep<R extends Record> This type is used for the Delete's DSL API.
interface	DeleteQuery<R extends Record> A query used for deletion of data
interface	DeleteWhereStep<R extends Record> This type is used for the Delete's DSL API.
interface	Field<T> A field used in tables and conditions
interface	GroupConcatOrderByStep MySQL's GROUP_CONCAT function.
interface	GroupConcatSeparatorStep MySQL's GROUP_CONCAT function.
interface	Insert<R extends Record> A Query that can insert data in the database.
interface	InsertFinalStep<R extends Record> This type is used for the Insert's DSL API.
interface	InsertOnDuplicateSetMoreStep<R extends Record> This type is used for the Insert's DSL API.
interface	InsertOnDuplicateStep<R extends Record> This type is used for the Insert's DSL API.
interface	InsertQuery<R extends Record> A query for data insertion
interface	InsertResultStep<R extends Record> This type is used for the Insert's DSL API.
interface	InsertSetMoreStep<R extends Record> This type is used for the Insert's alternative DSL API.
interface	InsertValuesStep<R extends Record> This type is used for the Insert's DSL API.
interface	Merge<R extends Record> A Query that can merge data in the database.
interface	MergeFinalStep<R extends Record> This type is used for the Merge's DSL API.
interface	MergeMatchedDeleteStep<R extends Record> This type is used for the Merge's DSL API.
interface	MergeMatchedSetMoreStep<R extends Record> This type is used for the Merge's DSL API.
interface	MergeMatchedStep<R extends Record> This type is used for the Merge's DSL API.
interface	MergeMatchedWhereStep<R extends Record> This type is used for the Merge's DSL API.
interface	MergeNotMatchedSetMoreStep<R extends Record> This type is used for the Merge's DSL API.
interface	MergeNotMatchedStep<R extends Record> This type is used for the Merge's DSL API.
interface	MergeNotMatchedWhereStep<R extends Record> This type is used for the Merge's DSL API.
interface	MergeOnConditionStep<R extends Record> This type is used for the Merge's DSL API.
interface	Name A SQL identifier QueryPart A Name is a QueryPart that renders a SQL identifier according to the Settings.getRenderNameStyle().
interface	NamedQueryPart A common interface for query parts that have a name.
interface	NamedTypeProviderQueryPart<T> Any object providing a type.
interface	Package A container for stored procedures and functions This is only supported in the SQLDialect.ORACLE dialect
interface	Param<T> A named parameter and/or bind value.
interface	Parameter<T> A parameter to a stored procedure or function.
interface	Query Any query
interface	QueryPartInternal Base functionality declaration for all query objects This interface is for JOOQ INTERNAL USE only.
interface	ResultQuery<R extends Record> A query that can return results.
interface	Routine<T> A routine is a callable object in your RDBMS.
interface	Schema An entity representing a database schema
interface	Select<R extends Record> A Query that can provide a Result after execution
interface	SelectConditionStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectConnectByConditionStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectConnectByStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectFinalStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectForUpdateOfStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectForUpdateStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectForUpdateWaitStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectFromStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectGroupByStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectHavingConditionStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectHavingStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectJoinStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectLimitStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectOffsetStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectOnConditionStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectOrderByStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectQuery A query for data selection
interface	SelectSelectStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectStartWithStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SelectWhereStep This type is used for the Select's DSL API when selecting generic Record types.
interface	SimpleSelectConditionStep<R extends Record> This type is used for the Select's DSL API when selecting specific Record types.
interface	SimpleSelectFinalStep<R extends Record> This type is used for the Select's DSL API when selecting specific Record types.
interface	SimpleSelectForUpdateOfStep<R extends Record> This type is used for the Select's DSL API when selecting specific Record types.
interface	SimpleSelectForUpdateStep<R extends Record> This type is used for the Select's DSL API when selecting specific Record types.
interface	SimpleSelectForUpdateWaitStep<R extends Record> This type is used for the Select's DSL API when selecting specific Record types.
interface	SimpleSelectLimitStep<R extends Record> This type is used for the Select's DSL API when selecting specific Record types.
interface	SimpleSelectOffsetStep<R extends Record> This type is used for the Select's DSL API when selecting specific Record types.
interface	SimpleSelectOrderByStep<R extends Record> This type is used for the Select's DSL API when selecting specific Record types.
interface	SimpleSelectQuery<R extends Record> A simple select query that provides Records from a single table, with no joins allowed.
interface	SimpleSelectWhereStep<R extends Record> This type is used for the Select's DSL API when selecting specific Record types.
interface	SortField<T> A wrapper for a Field and a SortField
interface	StoreQuery<R extends Record> A query storing objects to the database.
interface	Table<R extends Record> A table to be used in queries
interface	TableField<R extends Record,T> A field contained in a table
interface	TableLike<R extends Record> An object that can behave like a table (a table-like object)
interface	TableOnConditionStep An intermediate (optional) type for the construction of a JOIN clause, where the join criteria is added using an ON clause (with a Condition.
interface	Truncate<R extends Record> A Query that can truncate a table in the database.
interface	Type<R extends Record> Deprecated. - 2.5.0 [#1579] - The org.jooq.TypeTable and UDT with a single interface
interface	UDT<R extends UDTRecord<R>> UDT definition
interface	UDTField<R extends UDTRecord<R>,T> A field contained in a UDT
interface	UpdatableTable<R extends Record> A common interface for tables whose records can be stored back to the database again.
interface	Update<R extends Record> A Query that can update data in the database.
interface	UpdateConditionStep<R extends Record> This type is used for the Update's DSL API.
interface	UpdateFinalStep<R extends Record> This type is used for the Update's DSL API.
interface	UpdateQuery<R extends Record> A query for data updating
interface	UpdateSetMoreStep<R extends Record> This type is used for the Update's DSL API.
interface	UpdateWhereStep<R extends Record> This type is used for the Update's DSL API.
interface	WindowBeforeOverStep<T> This type is used for the window function DSL API.
interface	WindowFinalStep<T> This type is used for the window function DSL API.
interface	WindowOrderByStep<T> This type is used for the window function DSL API.
interface	WindowPartitionByStep<T> This type is used for the window function DSL API.
interface	WindowRowsStep<T> This type is used for the window function DSL API.

Methods in org.jooq with parameters of type QueryPart

UpdateConditionStep<R>	UpdateConditionStep.and(String sql, QueryPart... parts) 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	TableOnConditionStep.and(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.AND operator.
SimpleSelectConditionStep<R>	SimpleSelectConditionStep.and(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
SelectOnConditionStep	SelectOnConditionStep.and(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
SelectHavingConditionStep	SelectHavingConditionStep.and(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
SelectConnectByConditionStep	SelectConnectByConditionStep.and(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
SelectConditionStep	SelectConditionStep.and(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
MergeOnConditionStep<R>	MergeOnConditionStep.and(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.
DivideByOnConditionStep	DivideByOnConditionStep.and(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.AND operator.
DeleteConditionStep<R>	DeleteConditionStep.and(String sql, QueryPart... parts) 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(String sql, QueryPart... parts) Combine this condition with another one using the Operator.AND operator.
BindContext	BindContext.bind(QueryPart part) Bind values from a QueryPart.
BindContext	BindContext.bind(QueryPart[] parts) Bind values from several QueryPart's.
SelectConnectByConditionStep	SelectConnectByStep.connectBy(String sql, QueryPart... parts) Add an Oracle-specific CONNECT BY clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
SelectConnectByConditionStep	SelectConnectByStep.connectByNoCycle(String sql, QueryPart... parts) 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.crossJoin(String sql, QueryPart... parts) CROSS JOIN a table to this table.
SelectJoinStep	SelectJoinStep.crossJoin(String sql, QueryPart... parts) Convenience method to CROSS JOIN a table to the last table added to the FROM clause using Table.crossJoin(String, QueryPart...)
int	FactoryOperations.execute(String sql, QueryPart... parts) Execute a new query holding plain SQL.
Result<Record>	FactoryOperations.fetch(String sql, QueryPart... parts) Execute a new query holding plain SQL.
Cursor<Record>	FactoryOperations.fetchLazy(String sql, QueryPart... parts) Execute a new query holding plain SQL and "lazily" return the generated result.
List<Result<Record>>	FactoryOperations.fetchMany(String sql, QueryPart... parts) Execute a new query holding plain SQL, possibly returning several result sets.
Record	FactoryOperations.fetchOne(String sql, QueryPart... parts) Execute a new query holding plain SQL.
SelectJoinStep	SelectFromStep.from(String sql, QueryPart... parts) Add a FROM clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
TableOnStep	Table.fullOuterJoin(String sql, QueryPart... parts) FULL OUTER JOIN a table to this table.
SelectOnStep	SelectJoinStep.fullOuterJoin(String sql, QueryPart... parts) Convenience method to FULL OUTER JOIN a tableto the last table added to the FROM clause using Table.fullOuterJoin(String, QueryPart...)
SelectHavingConditionStep	SelectHavingStep.having(String sql, QueryPart... parts) Add a HAVING clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
TableOnStep	Table.join(String sql, QueryPart... parts) INNER JOIN a table to this table.
SelectOnStep	SelectJoinStep.join(String sql, QueryPart... parts) Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(String, QueryPart...)
TablePartitionByStep	Table.leftOuterJoin(String sql, QueryPart... parts) LEFT OUTER JOIN a table to this table.
SelectJoinPartitionByStep	SelectJoinStep.leftOuterJoin(String sql, QueryPart... parts) Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(String, QueryPart...)
Table<Record>	Table.naturalJoin(String sql, QueryPart... parts) NATURAL JOIN a table to this table.
SelectJoinStep	SelectJoinStep.naturalJoin(String sql, QueryPart... parts) Convenience method to NATURAL JOIN a table to the last table added to the FROM clause using Table.naturalJoin(String, QueryPart...)
Table<Record>	Table.naturalLeftOuterJoin(String sql, QueryPart... parts) NATURAL LEFT OUTER JOIN a table to this table.
SelectJoinStep	SelectJoinStep.naturalLeftOuterJoin(String sql, QueryPart... parts) Convenience method to NATURAL LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.naturalLeftOuterJoin(String, QueryPart...)
Table<Record>	Table.naturalRightOuterJoin(String sql, QueryPart... parts) NATURAL RIGHT OUTER JOIN a table to this table.
SelectJoinStep	SelectJoinStep.naturalRightOuterJoin(String sql, QueryPart... parts) Convenience method to NATURAL RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.naturalRightOuterJoin(String, QueryPart...)
TableOnConditionStep	TableOnStep.on(String sql, QueryPart... parts) Add an ON clause to the JOIN NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
SelectOnConditionStep	SelectOnStep.on(String sql, QueryPart... parts) Add an ON clause to the previous JOIN NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
MergeOnConditionStep<R>	MergeOnStep.on(String sql, QueryPart... parts) 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(String sql, QueryPart... parts) 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(String sql, QueryPart... parts) 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	TableOnConditionStep.or(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.OR operator.
SimpleSelectConditionStep<R>	SimpleSelectConditionStep.or(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.OR operator and proceed to the next step.
SelectOnConditionStep	SelectOnConditionStep.or(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.OR operator and proceed to the next step.
SelectHavingConditionStep	SelectHavingConditionStep.or(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.OR operator and proceed to the next step.
SelectConditionStep	SelectConditionStep.or(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.OR operator and proceed to the next step.
MergeOnConditionStep<R>	MergeOnConditionStep.or(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.OR operator and proceed to the next step.
DivideByOnConditionStep	DivideByOnConditionStep.or(String sql, QueryPart... parts) Combine the currently assembled conditions with another one using the Operator.OR operator.
DeleteConditionStep<R>	DeleteConditionStep.or(String sql, QueryPart... parts) 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(String sql, QueryPart... parts) Combine this condition with another one using the Operator.OR operator.
Query	FactoryOperations.query(String sql, QueryPart... parts) Create a new query holding plain SQL.
String	RenderContext.render(QueryPart part) Render a query part in a new context derived from this one.
String	FactoryOperations.render(QueryPart part) Render a QueryPart in the context of this factory This is the same as calling renderContext().render(part)
String	FactoryOperations.renderInlined(QueryPart part) Render a QueryPart in the context of this factory, inlining all bind variables.
String	FactoryOperations.renderNamedParams(QueryPart part) Render a QueryPart in the context of this factory, rendering bind variables as named parameters.
ResultQuery<Record>	FactoryOperations.resultQuery(String sql, QueryPart... parts) Create a new query holding plain SQL.
TablePartitionByStep	Table.rightOuterJoin(String sql, QueryPart... parts) RIGHT OUTER JOIN a table to this table.
SelectJoinPartitionByStep	SelectJoinStep.rightOuterJoin(String sql, QueryPart... parts) Convenience method to RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.rightOuterJoin(String, QueryPart...)
RenderContext	RenderContext.sql(QueryPart part) Recurse rendering
SelectGroupByStep	SelectStartWithStep.startWith(String sql, QueryPart... parts) Add an Oracle-specific START WITH clause to the query's CONNECT BY clause NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
UpdateConditionStep<R>	UpdateWhereStep.where(String sql, QueryPart... parts) Add conditions to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
SimpleSelectConditionStep<R>	SimpleSelectWhereStep.where(String sql, QueryPart... parts) Add a WHERE clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
SelectConditionStep	SelectWhereStep.where(String sql, QueryPart... parts) Add a WHERE clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
DeleteConditionStep<R>	DeleteWhereStep.where(String sql, QueryPart... parts) Add conditions to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

Method parameters in org.jooq with type arguments of type QueryPart

BindContext

BindContext.bind(Collection<? extends QueryPart> parts) Bind values from several QueryPart's.

Uses of QueryPart in org.jooq.impl

Classes in org.jooq.impl that implement QueryPart

class	AbstractRoutine<T> A common base class for stored procedures This type is for JOOQ INTERNAL USE only.
class	CustomCondition A base class for custom Condition implementations in client code.
class	CustomField<T> A base class for custom Field implementations in client code.
class	CustomTable<R extends TableRecord<R>> A base class for custom Table implementations in client code.
class	PackageImpl A default implementation for packages (containers of stored procedures and functions) Currently, this is only supported for the SQLDialect.ORACLE dialect.
class	SchemaImpl A common base class for database schemata This type is for JOOQ INTERNAL USE only.
class	TableImpl<R extends Record> A common base type for tables This type is for JOOQ INTERNAL USE only.
class	UDTImpl<R extends UDTRecord<R>> A common base type for UDT's This type is for JOOQ INTERNAL USE only.
class	UpdatableTableImpl<R extends Record> A table implementation for a table holding a primary key This type is for JOOQ INTERNAL USE only.

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

int	Factory.bind(QueryPart part, PreparedStatement stmt) Get a new BindContext for the context of this factory This will return an initialised bind context as such: Context.declareFields() == false Context.declareTables() == false RenderContext for JOOQ INTERNAL USE only.
static Condition	Factory.condition(String sql, QueryPart... parts) A custom SQL clause that can render arbitrary SQL elements.
int	FactoryProxy.execute(String sql, QueryPart... parts) Deprecated.
int	Factory.execute(String sql, QueryPart... parts) Execute a new query holding plain SQL.
Result<Record>	FactoryProxy.fetch(String sql, QueryPart... parts) Deprecated.
Result<Record>	Factory.fetch(String sql, QueryPart... parts) Execute a new query holding plain SQL.
Cursor<Record>	FactoryProxy.fetchLazy(String sql, QueryPart... parts) Deprecated.
Cursor<Record>	Factory.fetchLazy(String sql, QueryPart... parts) Execute a new query holding plain SQL and "lazily" return the generated result.
List<Result<Record>>	FactoryProxy.fetchMany(String sql, QueryPart... parts) Deprecated.
List<Result<Record>>	Factory.fetchMany(String sql, QueryPart... parts) Execute a new query holding plain SQL, possibly returning several result sets.
Record	FactoryProxy.fetchOne(String sql, QueryPart... parts) Deprecated.
Record	Factory.fetchOne(String sql, QueryPart... parts) Execute a new query holding plain SQL.
static <T> Field<T>	Factory.field(String sql, Class<T> type, QueryPart... parts) A custom SQL clause that can render arbitrary SQL elements.
static <T> Field<T>	Factory.field(String sql, DataType<T> type, QueryPart... parts) A custom SQL clause that can render arbitrary SQL elements.
static Field<Object>	Factory.field(String sql, QueryPart... parts) A custom SQL clause that can render arbitrary SQL elements.
Query	FactoryProxy.query(String sql, QueryPart... parts) Deprecated.
Query	Factory.query(String sql, QueryPart... parts) Create a new query holding plain SQL.
String	FactoryProxy.render(QueryPart part) Deprecated.
String	Factory.render(QueryPart part) Render a QueryPart in the context of this factory This is the same as calling renderContext().render(part)
String	FactoryProxy.renderInlined(QueryPart part) Deprecated.
String	Factory.renderInlined(QueryPart part) Render a QueryPart in the context of this factory, inlining all bind variables.
String	FactoryProxy.renderNamedParams(QueryPart part) Deprecated.
String	Factory.renderNamedParams(QueryPart part) Render a QueryPart in the context of this factory, rendering bind variables as named parameters.
ResultQuery<Record>	FactoryProxy.resultQuery(String sql, QueryPart... parts) Deprecated.
ResultQuery<Record>	Factory.resultQuery(String sql, QueryPart... parts) Create a new query holding plain SQL.