org.jooq/jooq/3.14.7 : org/jooq/SelectQuery.java

SelectQuery
http://www.jooq.org/jooq: jOOQ effectively combines complex SQL, typesafety, source code generation, active records, stored procedures, advanced data types, and Java in a fluent, intuitive DSL.
Apache License, Version 2.0
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Other licenses:
 * -----------------------------------------------------------------------------
 * Commercial licenses for this work are available. These replace the above
 * ASL 2.0 and offer limited warranties, support, maintenance, and commercial
 * database integrations.
 *
 * For more information, please visit: http://www.jooq.org/licenses
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
package org.jooq;

// ...
// ...
// ...
// ...
// ...
import static org.jooq.SQLDialect.CUBRID;
// ...
// ...
import static org.jooq.SQLDialect.DERBY;
import static org.jooq.SQLDialect.FIREBIRD;
// ...
import static org.jooq.SQLDialect.H2;
// ...
import static org.jooq.SQLDialect.HSQLDB;
// ...
// ...
import static org.jooq.SQLDialect.MARIADB;
// ...
// ...
// ...
import static org.jooq.SQLDialect.MYSQL;
// ...
// ...
// ...
// ...
import static org.jooq.SQLDialect.POSTGRES;
// ...
// ...
// ...
import static org.jooq.SQLDialect.SQLITE;
// ...
// ...
// ...
// ...

import java.util.Collection;

import org.jooq.exception.DataAccessException;

A SELECT statement (model API).
 This type is the model API representation of a Select statement, which can be mutated after creation. The advantage of this API compared to the DSL API is a more simple approach to writing dynamic SQL. 
 Instances can be created using DSLContext.selectQuery() and overloads. 
Author: Lukas Eder/**
 * A <code>SELECT</code> statement (model API).
 * <p>
 * This type is the model API representation of a {@link Select} statement,
 * which can be mutated after creation. The advantage of this API compared to
 * the DSL API is a more simple approach to writing dynamic SQL.
 * <p>
 * Instances can be created using {@link DSLContext#selectQuery()} and overloads.
 *
 * @author Lukas Eder
 */
@SuppressWarnings("deprecation")
public interface SelectQuery<R extends Record> extends Select<R>, ConditionProvider {

    Add a list of select fields.
Params: fields – /**
     * Add a list of select fields.
     *
     * @param fields
     */
    @Support
    void addSelect(SelectFieldOrAsterisk... fields);

    Add a list of select fields.
Params: fields – /**
     * Add a list of select fields.
     *
     * @param fields
     */
    @Support
    void addSelect(Collection<? extends SelectFieldOrAsterisk> fields);

    Add "distinct" keyword to the select clause.
/**
     * Add "distinct" keyword to the select clause.
     */
    @Support
    void setDistinct(boolean distinct);

    Add a PostgreSQL-specific DISTINCT ON (fields...) clause.

This also sets the distinct flag to true
/**
     * Add a PostgreSQL-specific <code>DISTINCT ON (fields...)</code> clause.
     * <p>
     * This also sets the <code>distinct</code> flag to <code>true</code>
     */
    @Support({ CUBRID, FIREBIRD, H2, MARIADB, MYSQL, POSTGRES, SQLITE })
    void addDistinctOn(SelectFieldOrAsterisk... fields);

    Add a PostgreSQL-specific DISTINCT ON (fields...) clause.

This also sets the distinct flag to true
/**
     * Add a PostgreSQL-specific <code>DISTINCT ON (fields...)</code> clause.
     * <p>
     * This also sets the <code>distinct</code> flag to <code>true</code>
     */
    @Support({ CUBRID, FIREBIRD, H2, MARIADB, MYSQL, POSTGRES, SQLITE })
    void addDistinctOn(Collection<? extends SelectFieldOrAsterisk> fields);

    Add INTO clause to the SELECT statement.
/**
     * Add <code>INTO</code> clause to the <code>SELECT</code> statement.
     */
    @Support({ CUBRID, DERBY, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE })
    void setInto(Table<?> table);

    Add tables to the table product.
Params: from – The added tables/**
     * Add tables to the table product.
     *
     * @param from The added tables
     */
    @Support
    void addFrom(TableLike<?> from);

    Add tables to the table product.
Params: from – The added tables/**
     * Add tables to the table product.
     *
     * @param from The added tables
     */
    @Support
    void addFrom(TableLike<?>... from);

    Add tables to the table product.
Params: from – The added tables/**
     * Add tables to the table product.
     *
     * @param from The added tables
     */
    @Support
    void addFrom(Collection<? extends TableLike<?>> from);

    Joins the existing table product to a new table using a condition, connecting them with each other with Operator.AND. 
Params: table – The joined table
condition – The joining condition/**
     * Joins the existing table product to a new table using a condition,
     * connecting them with each other with {@link Operator#AND}.
     *
     * @param table The joined table
     * @param condition The joining condition
     */
    @Support
    void addJoin(TableLike<?> table, Condition condition);

    Joins the existing table product to a new table using a condition, connecting them with each other with Operator.AND. 
Params: table – The joined table
conditions – The joining conditions/**
     * Joins the existing table product to a new table using a condition,
     * connecting them with each other with {@link Operator#AND}.
     *
     * @param table The joined table
     * @param conditions The joining conditions
     */
    @Support
    void addJoin(TableLike<?> table, Condition... conditions);

    Joins the existing table product to a new table using a condition, connecting them with each other with Operator.AND. 
Params: table – The joined table
type – The type of join
condition – The joining condition/**
     * Joins the existing table product to a new table using a condition,
     * connecting them with each other with {@link Operator#AND}.
     *
     * @param table The joined table
     * @param type The type of join
     * @param condition The joining condition
     */
    @Support
    void addJoin(TableLike<?> table, JoinType type, Condition condition);

    Joins the existing table product to a new table using a condition, connecting them with each other with Operator.AND. 
Params: table – The joined table
type – The type of join
conditions – The joining conditions/**
     * Joins the existing table product to a new table using a condition,
     * connecting them with each other with {@link Operator#AND}.
     *
     * @param table The joined table
     * @param type The type of join
     * @param conditions The joining conditions
     */
    @Support
    void addJoin(TableLike<?> table, JoinType type, Condition... conditions);





































    Joins the existing table product to a new table with a USING
clause.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.
Params: table – The joined table
fields – The fields for the USING clause/**
     * Joins the existing table product to a new table with a <code>USING</code>
     * clause.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     *
     * @param table The joined table
     * @param fields The fields for the <code>USING</code> clause
     */
    @Support
    void addJoinUsing(TableLike<?> table, Collection<? extends Field<?>> fields);

    Joins the existing table product to a new table with a USING
clause.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.
Params: table – The joined table
type – The type of join
fields – The fields for the USING clause/**
     * Joins the existing table product to a new table with a <code>USING</code>
     * clause.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     *
     * @param table The joined table
     * @param type The type of join
     * @param fields The fields for the <code>USING</code> clause
     */
    @Support
    void addJoinUsing(TableLike<?> table, JoinType type, Collection<? extends Field<?>> fields);

    Joins the existing table product to a new table using a foreign key.
Params: table – The joined table
type – The type of join
Throws: DataAccessException – If there is no non-ambiguous key definition
            known to jOOQ
See Also: TableOnStep.onKey(ForeignKey)/**
     * Joins the existing table product to a new table using a foreign key.
     *
     * @param table The joined table
     * @param type The type of join
     * @see TableOnStep#onKey(ForeignKey)
     * @throws DataAccessException If there is no non-ambiguous key definition
     *             known to jOOQ
     */
    @Support
    void addJoinOnKey(TableLike<?> table, JoinType type) throws DataAccessException;

    Joins the existing table product to a new table using a foreign key.
Params: table – The joined table
type – The type of join
keyFields – The foreign key fields
Throws: DataAccessException – If there is no non-ambiguous key definition
            known to jOOQ
See Also: TableOnStep.onKey(ForeignKey)/**
     * Joins the existing table product to a new table using a foreign key.
     *
     * @param table The joined table
     * @param type The type of join
     * @param keyFields The foreign key fields
     * @see TableOnStep#onKey(ForeignKey)
     * @throws DataAccessException If there is no non-ambiguous key definition
     *             known to jOOQ
     */
    @Support
    void addJoinOnKey(TableLike<?> table, JoinType type, TableField<?, ?>... keyFields) throws DataAccessException;

    Joins the existing table product to a new table using a foreign key.
Params: table – The joined table
type – The type of join
key – The foreign key
See Also: TableOnStep.onKey(ForeignKey)/**
     * Joins the existing table product to a new table using a foreign key.
     *
     * @param table The joined table
     * @param type The type of join
     * @param key The foreign key
     * @see TableOnStep#onKey(ForeignKey)
     */
    @Support
    void addJoinOnKey(TableLike<?> table, JoinType type, ForeignKey<?, ?> key);

    Adds grouping fields.

Calling this with an empty argument list will result in an empty
GROUP BY () clause being rendered.
Params: fields – The grouping fields/**
     * Adds grouping fields.
     * <p>
     * Calling this with an empty argument list will result in an empty
     * <code>GROUP BY ()</code> clause being rendered.
     *
     * @param fields The grouping fields
     */
    @Support
    void addGroupBy(GroupField... fields);

    Adds grouping fields.

Calling this with an empty argument list will result in an empty
GROUP BY () clause being rendered.
Params: fields – The grouping fields/**
     * Adds grouping fields.
     * <p>
     * Calling this with an empty argument list will result in an empty
     * <code>GROUP BY ()</code> clause being rendered.
     *
     * @param fields The grouping fields
     */
    @Support
    void addGroupBy(Collection<? extends GroupField> fields);

    Adds a new condition to the having clause of the query, connecting it with each other with Operator.AND. 
Params: condition – The condition/**
     * Adds a new condition to the having clause of the query, connecting it
     * with each other with {@link Operator#AND}.
     *
     * @param condition The condition
     */
    @Support
    void addHaving(Condition condition);

    Adds new conditions to the having clause of the query, connecting them with each other with Operator.AND. 
Params: conditions – The condition/**
     * Adds new conditions to the having clause of the query, connecting them
     * with each other with {@link Operator#AND}.
     *
     * @param conditions The condition
     */
    @Support
    void addHaving(Condition... conditions);

    Adds new conditions to the having clause of the query, connecting them with each other with Operator.AND. 
Params: conditions – The condition/**
     * Adds new conditions to the having clause of the query, connecting them
     * with each other with {@link Operator#AND}.
     *
     * @param conditions The condition
     */
    @Support
    void addHaving(Collection<? extends Condition> conditions);

    Adds a new condition to the having clause of query, connecting it with
each other with operator.
Params: operator – The operator to use to add the conditions to the existing
           conditions
condition – The condition/**
     * Adds a new condition to the having clause of query, connecting it with
     * each other with <code>operator</code>.
     *
     * @param operator The operator to use to add the conditions to the existing
     *            conditions
     * @param condition The condition
     */
    @Support
    void addHaving(Operator operator, Condition condition);

    Adds new conditions to the having clause of query, connecting them with
each other with operator.
Params: operator – The operator to use to add the conditions to the existing
           conditions
conditions – The condition/**
     * Adds new conditions to the having clause of query, connecting them with
     * each other with <code>operator</code>.
     *
     * @param operator The operator to use to add the conditions to the existing
     *            conditions
     * @param conditions The condition
     */
    @Support
    void addHaving(Operator operator, Condition... conditions);

    Adds new conditions to the having clause of query, connecting them with
each other with operator.
Params: operator – The operator to use to add the conditions to the existing
           conditions
conditions – The condition/**
     * Adds new conditions to the having clause of query, connecting them with
     * each other with <code>operator</code>.
     *
     * @param operator The operator to use to add the conditions to the existing
     *            conditions
     * @param conditions The condition
     */
    @Support
    void addHaving(Operator operator, Collection<? extends Condition> conditions);

    Adds new window definitions to the window clause of the query.
Params: definitions – The definitions/**
     * Adds new window definitions to the window clause of the query.
     *
     * @param definitions The definitions
     */
    @Support({ CUBRID, FIREBIRD, H2, MARIADB, MYSQL, POSTGRES, SQLITE })
    void addWindow(WindowDefinition... definitions);

    Adds new window definitions to the window clause of the query.
Params: definitions – The definitions/**
     * Adds new window definitions to the window clause of the query.
     *
     * @param definitions The definitions
     */
    @Support({ CUBRID, FIREBIRD, H2, MARIADB, MYSQL, POSTGRES, SQLITE })
    void addWindow(Collection<? extends WindowDefinition> definitions);

    Adds a new condition to the qualify clause of the query, connecting it with each other with Operator.AND. 
Params: condition – The condition/**
     * Adds a new condition to the qualify clause of the query, connecting it
     * with each other with {@link Operator#AND}.
     *
     * @param condition The condition
     */
    @Support({ H2 })
    void addQualify(Condition condition);

    Adds new conditions to the qualify clause of the query, connecting them with each other with Operator.AND. 
Params: conditions – The condition/**
     * Adds new conditions to the qualify clause of the query, connecting them
     * with each other with {@link Operator#AND}.
     *
     * @param conditions The condition
     */
    @Support({ H2 })
    void addQualify(Condition... conditions);

    Adds new conditions to the qualify clause of the query, connecting them with each other with Operator.AND. 
Params: conditions – The condition/**
     * Adds new conditions to the qualify clause of the query, connecting them
     * with each other with {@link Operator#AND}.
     *
     * @param conditions The condition
     */
    @Support({ H2 })
    void addQualify(Collection<? extends Condition> conditions);

    Adds a new condition to the qualify clause of query, connecting it with
each other with operator.
Params: operator – The operator to use to add the conditions to the existing
           conditions
condition – The condition/**
     * Adds a new condition to the qualify clause of query, connecting it with
     * each other with <code>operator</code>.
     *
     * @param operator The operator to use to add the conditions to the existing
     *            conditions
     * @param condition The condition
     */
    @Support({ H2 })
    void addQualify(Operator operator, Condition condition);

    Adds new conditions to the qualify clause of query, connecting them with
each other with operator.
Params: operator – The operator to use to add the conditions to the existing
           conditions
conditions – The condition/**
     * Adds new conditions to the qualify clause of query, connecting them with
     * each other with <code>operator</code>.
     *
     * @param operator The operator to use to add the conditions to the existing
     *            conditions
     * @param conditions The condition
     */
    @Support({ H2 })
    void addQualify(Operator operator, Condition... conditions);

    Adds new conditions to the qualify clause of query, connecting them with
each other with operator.
Params: operator – The operator to use to add the conditions to the existing
           conditions
conditions – The condition/**
     * Adds new conditions to the qualify clause of query, connecting them with
     * each other with <code>operator</code>.
     *
     * @param operator The operator to use to add the conditions to the existing
     *            conditions
     * @param conditions The condition
     */
    @Support({ H2 })
    void addQualify(Operator operator, Collection<? extends Condition> conditions);

    Add an Oracle-style hint to the select clause.

Example: 
DSLContext create = DSL.using(configuration);
create.select(field1, field2)
      .hint("/*+ALL_ROWS*/")
      .from(table1)
      .execute();


You can also use this clause for any other database, that accepts hints
or options at the same syntactic location, e.g. for MySQL's
SQL_CALC_FOUND_ROWS option: 
create.select(field1, field2)
      .hint("SQL_CALC_FOUND_ROWS")
      .from(table1)
      .fetch();


The outcome of such a query is this: 
SELECT [hint] field1, field2 FROM table1

 For SQL Server style table hints, see Table.with(String) 
See Also: Table.with(String)/**
     * Add an Oracle-style hint to the select clause.
     * <p>
     * Example: <code><pre>
     * DSLContext create = DSL.using(configuration);
     *
     * create.select(field1, field2)
     *       .hint("/*+ALL_ROWS&#42;/")
     *       .from(table1)
     *       .execute();
     * </pre></code>
     * <p>
     * You can also use this clause for any other database, that accepts hints
     * or options at the same syntactic location, e.g. for MySQL's
     * <code>SQL_CALC_FOUND_ROWS</code> option: <code><pre>
     * create.select(field1, field2)
     *       .hint("SQL_CALC_FOUND_ROWS")
     *       .from(table1)
     *       .fetch();
     * </pre></code>
     * <p>
     * The outcome of such a query is this: <code><pre>
     * SELECT [hint] field1, field2 FROM table1
     * </pre></code>
     * <p>
     * For SQL Server style table hints, see {@link Table#with(String)}
     *
     * @see Table#with(String)
     */
    @Support
    void addHint(String hint);

    Add a SQL Server-style query hint to the select clause.

Example: 
DSLContext create = DSL.using(configuration);
create.select(field1, field2)
      .from(table1)
      .option("OPTION (OPTIMIZE FOR UNKNOWN)")
      .execute();


You can also use this clause for any other database, that accepts hints
or options at the same syntactic location, e.g. for DB2's isolation clause: 
create.select(field1, field2)
      .from(table1)
      .option("WITH RR USE AND KEEP EXCLUSIVE LOCKS")
      .execute();


The outcome of such a query is this: 
SELECT field1, field2 FROM table1 [option]

 For SQL Server style table hints, see Table.with(String) 
See Also: Table.with(String)/**
     * Add a SQL Server-style query hint to the select clause.
     * <p>
     * Example: <code><pre>
     * DSLContext create = DSL.using(configuration);
     *
     * create.select(field1, field2)
     *       .from(table1)
     *       .option("OPTION (OPTIMIZE FOR UNKNOWN)")
     *       .execute();
     * </pre></code>
     * <p>
     * You can also use this clause for any other database, that accepts hints
     * or options at the same syntactic location, e.g. for DB2's isolation clause: <code><pre>
     * create.select(field1, field2)
     *       .from(table1)
     *       .option("WITH RR USE AND KEEP EXCLUSIVE LOCKS")
     *       .execute();
     * </pre></code>
     * <p>
     * The outcome of such a query is this: <code><pre>
     * SELECT field1, field2 FROM table1 [option]
     * </pre></code>
     * <p>
     * For SQL Server style table hints, see {@link Table#with(String)}
     *
     * @see Table#with(String)
     */
    @Support
    void addOption(String option);




























    // ------------------------------------------------------------------------
    // Methods from ConditionProvider, OrderProvider, LockProvider
    // ------------------------------------------------------------------------

    @Override
    @Support
    void addConditions(Condition condition);

    @Override
    @Support
    void addConditions(Condition... conditions);

    @Override
    @Support
    void addConditions(Collection<? extends Condition> conditions);

    @Override
    @Support
    void addConditions(Operator operator, Condition condition);

    @Override
    @Support
    void addConditions(Operator operator, Condition... conditions);

    @Override
    @Support
    void addConditions(Operator operator, Collection<? extends Condition> conditions);

    Adds ordering fields.
Params: fields – The ordering fields/**
     * Adds ordering fields.
     *
     * @param fields The ordering fields
     */
    @Support
    void addOrderBy(OrderField<?>... fields);

    Adds ordering fields.
Params: fields – The ordering fields/**
     * Adds ordering fields.
     *
     * @param fields The ordering fields
     */
    @Support
    void addOrderBy(Collection<? extends OrderField<?>> fields);

    Adds ordering fields.

Indexes start at 1 in SQL!

Note, you can use addOrderBy(DSL.val(1).desc()) or
addOrderBy(DSL.literal(1).desc()) to apply descending
ordering
Params: fieldIndexes – The ordering fields/**
     * Adds ordering fields.
     * <p>
     * Indexes start at <code>1</code> in SQL!
     * <p>
     * Note, you can use <code>addOrderBy(DSL.val(1).desc())</code> or
     * <code>addOrderBy(DSL.literal(1).desc())</code> to apply descending
     * ordering
     *
     * @param fieldIndexes The ordering fields
     */
    @Support
    void addOrderBy(int... fieldIndexes);




















    Adds seeking fields.
Params: fields – The seeking fields/**
     * Adds seeking fields.
     *
     * @param fields The seeking fields
     */
    @Support
    void addSeekAfter(Field<?>... fields);

    Adds seeking fields.
Params: fields – The seeking fields/**
     * Adds seeking fields.
     *
     * @param fields The seeking fields
     */
    @Support
    void addSeekAfter(Collection<? extends Field<?>> fields);

    Adds seeking fields.
Params: fields – The seeking fields
Deprecated: - [#7461] - SEEK BEFORE is not implemented correctly/**
     * Adds seeking fields.
     *
     * @param fields The seeking fields
     * @deprecated - [#7461] - SEEK BEFORE is not implemented correctly
     */
    @Deprecated
    @Support
    void addSeekBefore(Field<?>... fields);

    Adds seeking fields.
Params: fields – The seeking fields
Deprecated: - [#7461] - SEEK BEFORE is not implemented correctly/**
     * Adds seeking fields.
     *
     * @param fields The seeking fields
     * @deprecated - [#7461] - SEEK BEFORE is not implemented correctly
     */
    @Deprecated
    @Support
    void addSeekBefore(Collection<? extends Field<?>> fields);

    Add an OFFSET clause to the query.

If there is no LIMIT .. OFFSET or TOP clause in
your RDBMS, or if your RDBMS does not natively support offsets, this is
emulated with a ROW_NUMBER() window function and nested
SELECT statements.
/**
     * Add an <code>OFFSET</code> clause to the query.
     * <p>
     * If there is no <code>LIMIT .. OFFSET</code> or <code>TOP</code> clause in
     * your RDBMS, or if your RDBMS does not natively support offsets, this is
     * emulated with a <code>ROW_NUMBER()</code> window function and nested
     * <code>SELECT</code> statements.
     */
    @Support
    void addOffset(int offset);

    Add an OFFSET clause to the query.

If there is no LIMIT .. OFFSET or TOP clause in
your RDBMS, or if your RDBMS does not natively support offsets, this is
emulated with a ROW_NUMBER() window function and nested
SELECT statements.
/**
     * Add an <code>OFFSET</code> clause to the query.
     * <p>
     * If there is no <code>LIMIT .. OFFSET</code> or <code>TOP</code> clause in
     * your RDBMS, or if your RDBMS does not natively support offsets, this is
     * emulated with a <code>ROW_NUMBER()</code> window function and nested
     * <code>SELECT</code> statements.
     */
    @Support
    void addOffset(Number offset);

    Add an OFFSET clause to the query using a named parameter.

If there is no LIMIT .. OFFSET or TOP clause in
your RDBMS, or if your RDBMS does not natively support offsets, this is
emulated with a ROW_NUMBER() window function and nested
SELECT statements.
/**
     * Add an <code>OFFSET</code> clause to the query using a named parameter.
     * <p>
     * If there is no <code>LIMIT .. OFFSET</code> or <code>TOP</code> clause in
     * your RDBMS, or if your RDBMS does not natively support offsets, this is
     * emulated with a <code>ROW_NUMBER()</code> window function and nested
     * <code>SELECT</code> statements.
     */
    @Support
    void addOffset(Param<? extends Number> offset);

    Limit the results of this select.
 This is the same as calling addLimit(int, int) with offset = 0 
Params: numberOfRows – The number of rows to return/**
     * Limit the results of this select.
     * <p>
     * This is the same as calling {@link #addLimit(int, int)} with offset = 0
     *
     * @param numberOfRows The number of rows to return
     */
    @Support
    void addLimit(int numberOfRows);

    Limit the results of this select.
 This is the same as calling addLimit(int, int) with offset = 0 
Params: numberOfRows – The number of rows to return/**
     * Limit the results of this select.
     * <p>
     * This is the same as calling {@link #addLimit(int, int)} with offset = 0
     *
     * @param numberOfRows The number of rows to return
     */
    @Support
    void addLimit(Number numberOfRows);

    Limit the results of this select using named parameters.

Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!

If there is no LIMIT or TOP clause in your
RDBMS, or the LIMIT or TOP clause does not
support bind values, this may be emulated with a
ROW_NUMBER() window function and nested SELECT
statements.
 This is the same as calling addLimit(int, int) with offset = 0 
Params: numberOfRows – The number of rows to return/**
     * Limit the results of this select using named parameters.
     * <p>
     * Note that some dialects do not support bind values at all in
     * <code>LIMIT</code> or <code>TOP</code> clauses!
     * <p>
     * If there is no <code>LIMIT</code> or <code>TOP</code> clause in your
     * RDBMS, or the <code>LIMIT</code> or <code>TOP</code> clause does not
     * support bind values, this may be emulated with a
     * <code>ROW_NUMBER()</code> window function and nested <code>SELECT</code>
     * statements.
     * <p>
     * This is the same as calling {@link #addLimit(int, int)} with offset = 0
     *
     * @param numberOfRows The number of rows to return
     */
    @Support
    void addLimit(Param<? extends Number> numberOfRows);

    Limit the results of this select.

Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!

If there is no LIMIT or TOP clause in your
RDBMS, or if your RDBMS does not natively support offsets, this is
emulated with a ROW_NUMBER() window function and nested
SELECT statements.
Params: offset – The lowest offset starting at 0
numberOfRows – The number of rows to return/**
     * Limit the results of this select.
     * <p>
     * Note that some dialects do not support bind values at all in
     * <code>LIMIT</code> or <code>TOP</code> clauses!
     * <p>
     * If there is no <code>LIMIT</code> or <code>TOP</code> clause in your
     * RDBMS, or if your RDBMS does not natively support offsets, this is
     * emulated with a <code>ROW_NUMBER()</code> window function and nested
     * <code>SELECT</code> statements.
     *
     * @param offset The lowest offset starting at 0
     * @param numberOfRows The number of rows to return
     */
    @Support
    void addLimit(int offset, int numberOfRows);

    Limit the results of this select.

Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!

If there is no LIMIT or TOP clause in your
RDBMS, or if your RDBMS does not natively support offsets, this is
emulated with a ROW_NUMBER() window function and nested
SELECT statements.
Params: offset – The lowest offset starting at 0
numberOfRows – The number of rows to return/**
     * Limit the results of this select.
     * <p>
     * Note that some dialects do not support bind values at all in
     * <code>LIMIT</code> or <code>TOP</code> clauses!
     * <p>
     * If there is no <code>LIMIT</code> or <code>TOP</code> clause in your
     * RDBMS, or if your RDBMS does not natively support offsets, this is
     * emulated with a <code>ROW_NUMBER()</code> window function and nested
     * <code>SELECT</code> statements.
     *
     * @param offset The lowest offset starting at 0
     * @param numberOfRows The number of rows to return
     */
    @Support
    void addLimit(Number offset, Number numberOfRows);

    Limit the results of this select.

Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!

If there is no LIMIT or TOP clause in your
RDBMS, or the LIMIT or TOP clause does not
support bind values, or if your RDBMS does not natively support offsets,
this may be emulated with a ROW_NUMBER() window function
and nested SELECT statements.
Params: offset – The lowest offset starting at 0
numberOfRows – The number of rows to return/**
     * Limit the results of this select.
     * <p>
     * Note that some dialects do not support bind values at all in
     * <code>LIMIT</code> or <code>TOP</code> clauses!
     * <p>
     * If there is no <code>LIMIT</code> or <code>TOP</code> clause in your
     * RDBMS, or the <code>LIMIT</code> or <code>TOP</code> clause does not
     * support bind values, or if your RDBMS does not natively support offsets,
     * this may be emulated with a <code>ROW_NUMBER()</code> window function
     * and nested <code>SELECT</code> statements.
     *
     * @param offset The lowest offset starting at 0
     * @param numberOfRows The number of rows to return
     */
    @Support
    void addLimit(Param<Integer> offset, int numberOfRows);

    Limit the results of this select.

Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!

If there is no LIMIT or TOP clause in your
RDBMS, or the LIMIT or TOP clause does not
support bind values, or if your RDBMS does not natively support offsets,
this may be emulated with a ROW_NUMBER() window function
and nested SELECT statements.
Params: offset – The lowest offset starting at 0
numberOfRows – The number of rows to return/**
     * Limit the results of this select.
     * <p>
     * Note that some dialects do not support bind values at all in
     * <code>LIMIT</code> or <code>TOP</code> clauses!
     * <p>
     * If there is no <code>LIMIT</code> or <code>TOP</code> clause in your
     * RDBMS, or the <code>LIMIT</code> or <code>TOP</code> clause does not
     * support bind values, or if your RDBMS does not natively support offsets,
     * this may be emulated with a <code>ROW_NUMBER()</code> window function
     * and nested <code>SELECT</code> statements.
     *
     * @param offset The lowest offset starting at 0
     * @param numberOfRows The number of rows to return
     */
    @Support
    void addLimit(Param<? extends Number> offset, Number numberOfRows);

    Limit the results of this select using named parameters.

Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!

If there is no LIMIT or TOP clause in your
RDBMS, or the LIMIT or TOP clause does not
support bind values, or if your RDBMS does not natively support offsets,
this may be emulated with a ROW_NUMBER() window function
and nested SELECT statements.
Params: offset – The lowest offset starting at 0
numberOfRows – The number of rows to return/**
     * Limit the results of this select using named parameters.
     * <p>
     * Note that some dialects do not support bind values at all in
     * <code>LIMIT</code> or <code>TOP</code> clauses!
     * <p>
     * If there is no <code>LIMIT</code> or <code>TOP</code> clause in your
     * RDBMS, or the <code>LIMIT</code> or <code>TOP</code> clause does not
     * support bind values, or if your RDBMS does not natively support offsets,
     * this may be emulated with a <code>ROW_NUMBER()</code> window function
     * and nested <code>SELECT</code> statements.
     *
     * @param offset The lowest offset starting at 0
     * @param numberOfRows The number of rows to return
     */
    @Support
    void addLimit(int offset, Param<Integer> numberOfRows);

    Limit the results of this select using named parameters.

Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!

If there is no LIMIT or TOP clause in your
RDBMS, or the LIMIT or TOP clause does not
support bind values, or if your RDBMS does not natively support offsets,
this may be emulated with a ROW_NUMBER() window function
and nested SELECT statements.
Params: offset – The lowest offset starting at 0
numberOfRows – The number of rows to return/**
     * Limit the results of this select using named parameters.
     * <p>
     * Note that some dialects do not support bind values at all in
     * <code>LIMIT</code> or <code>TOP</code> clauses!
     * <p>
     * If there is no <code>LIMIT</code> or <code>TOP</code> clause in your
     * RDBMS, or the <code>LIMIT</code> or <code>TOP</code> clause does not
     * support bind values, or if your RDBMS does not natively support offsets,
     * this may be emulated with a <code>ROW_NUMBER()</code> window function
     * and nested <code>SELECT</code> statements.
     *
     * @param offset The lowest offset starting at 0
     * @param numberOfRows The number of rows to return
     */
    @Support
    void addLimit(Number offset, Param<? extends Number> numberOfRows);

    Limit the results of this select using named parameters.

Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!

If there is no LIMIT or TOP clause in your
RDBMS, or the LIMIT or TOP clause does not
support bind values, or if your RDBMS does not natively support offsets,
this may be emulated with a ROW_NUMBER() window function
and nested SELECT statements.
Params: offset – The lowest offset starting at 0
numberOfRows – The number of rows to return/**
     * Limit the results of this select using named parameters.
     * <p>
     * Note that some dialects do not support bind values at all in
     * <code>LIMIT</code> or <code>TOP</code> clauses!
     * <p>
     * If there is no <code>LIMIT</code> or <code>TOP</code> clause in your
     * RDBMS, or the <code>LIMIT</code> or <code>TOP</code> clause does not
     * support bind values, or if your RDBMS does not natively support offsets,
     * this may be emulated with a <code>ROW_NUMBER()</code> window function
     * and nested <code>SELECT</code> statements.
     *
     * @param offset The lowest offset starting at 0
     * @param numberOfRows The number of rows to return
     */
    @Support
    void addLimit(Param<? extends Number> offset, Param<? extends Number> numberOfRows);

    Add the PERCENT clause to a LIMIT clause.
/**
     * Add the <code>PERCENT</code> clause to a <code>LIMIT</code> clause.
     */
    @Support({ H2 })
    void setLimitPercent(boolean percent);

    Add the WITH TIES clause to a LIMIT clause.
/**
     * Add the <code>WITH TIES</code> clause to a <code>LIMIT</code> clause.
     */
    @Support({ CUBRID, FIREBIRD, H2, MARIADB, MYSQL, POSTGRES })
    void setWithTies(boolean withTies);

    Sets the "FOR UPDATE" lock mode onto the query.

Native implementation

This has been observed to be supported by any of these dialects:

DB2 FOR UPDATE and similar clauses
 Derby's
FOR UPDATE clause
H2's FOR
UPDATE clause
HSQLDB's FOR UPDATE clause
MySQL's InnoDB locking reads
Oracle's
PL/SQL FOR UPDATE clause
Postgres FOR UPDATE / FOR SHARE


Emulation
 SQLDialect.SQLSERVER: jOOQ will try to lock the database record using WITH (ROWLOCK, UPDLOCK) hints.
Not supported

These dialects are known not to support the FOR UPDATE
clause in regular SQL:

SQLDialect.SQLITE


If your dialect does not support this clause, jOOQ will still render it,
if you apply it to your query. This might then cause syntax errors
reported either by your database or your JDBC driver.
 You shouldn't combine this with setForShare(boolean) 
Params: forUpdate – The flag's value/**
     * Sets the "FOR UPDATE" lock mode onto the query.
     * <p>
     * <h5>Native implementation</h5>
     * <p>
     * This has been observed to be supported by any of these dialects:
     * <ul>
     * <li><a href=
     * "http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/index.jsp?topic=/com.ibm.db2.luw.sql.ref.doc/doc/r0000879.html"
     * >DB2 FOR UPDATE and similar clauses</a></li>
     * <li><a href=
     * "http://db.apache.org/derby/docs/10.7/ref/rrefsqlj31783.html"> Derby's
     * FOR UPDATE clause</a></li>
     * <li><a href="http://www.h2database.com/html/grammar.html#select">H2's FOR
     * UPDATE clause</a></li>
     * <li><a href=
     * "http://www.hsqldb.org/doc/2.0/guide/dataaccess-chapt.html#N11DA9"
     * >HSQLDB's FOR UPDATE clause</a></li>
     * <li><a href=
     * "http://dev.mysql.com/doc/refman/5.5/en/innodb-locking-reads.html"
     * >MySQL's InnoDB locking reads</a></li>
     * <li><a href=
     * "http://www.techonthenet.com/oracle/cursors/for_update.php">Oracle's
     * PL/SQL FOR UPDATE clause</a></li>
     * <li><a href=
     * "http://www.postgresql.org/docs/9.0/static/sql-select.html#SQL-FOR-UPDATE-SHARE"
     * >Postgres FOR UPDATE / FOR SHARE</a></li>
     * </ul>
     * <p>
     * <h5>Emulation</h5>
     * <p>
     * {@link SQLDialect#SQLSERVER}: jOOQ will try to lock the database record
     * using <code>WITH (ROWLOCK, UPDLOCK)</code> hints.
     * <h5>Not supported</h5>
     * <p>
     * These dialects are known not to support the <code>FOR UPDATE</code>
     * clause in regular SQL:
     * <ul>
     * <li>{@link SQLDialect#SQLITE}</li>
     * </ul>
     * <p>
     * If your dialect does not support this clause, jOOQ will still render it,
     * if you apply it to your query. This might then cause syntax errors
     * reported either by your database or your JDBC driver.
     * <p>
     * You shouldn't combine this with {@link #setForShare(boolean)}
     *
     * @param forUpdate The flag's value
     */
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    void setForUpdate(boolean forUpdate);

    Sets the "FOR NO KEY UPDATE" lock mode onto the query.
/**
     * Sets the "FOR NO KEY UPDATE" lock mode onto the query.
     */
    @Support({ POSTGRES })
    void setForNoKeyUpdate(boolean forNoKeyUpdate);

    Some RDBMS allow for specifying the fields that should be locked by the
FOR UPDATE clause, instead of the full row.
 This automatically sets the setForUpdate(boolean) flag, and unsets the setForShare(boolean) flag, if it was previously set. 

This has been observed to be natively supported by any of these dialects:

DB2
Derby
H2
HSQLDB
Ingres
Oracle
Sybase

 Note, that SQLDialect.DB2 has some stricter requirements regarding the updatability of fields. Refer to the DB2 documentation for further details 
Params: fields – The fields that should be locked
Deprecated: [#5218] - 3.14.0 - Use setForLockModeOf(Field...)/**
     * Some RDBMS allow for specifying the fields that should be locked by the
     * <code>FOR UPDATE</code> clause, instead of the full row.
     * <p>
     * This automatically sets the {@link #setForUpdate(boolean)} flag, and
     * unsets the {@link #setForShare(boolean)} flag, if it was previously set.
     * <p>
     * This has been observed to be natively supported by any of these dialects:
     * <ul>
     * <li>DB2</li>
     * <li>Derby</li>
     * <li>H2</li>
     * <li>HSQLDB</li>
     * <li>Ingres</li>
     * <li>Oracle</li>
     * <li>Sybase</li>
     * </ul>
     * <p>
     * Note, that {@link SQLDialect#DB2} has some stricter requirements
     * regarding the updatability of fields. Refer to the DB2 documentation for
     * further details
     *
     * @param fields The fields that should be locked
     *
     * @deprecated [#5218] - 3.14.0 - Use {@link #setForLockModeOf(Field...)}
     */
    @Deprecated
    @Support({ DERBY, FIREBIRD, H2, HSQLDB })
    void setForUpdateOf(Field<?>... fields);

    Some RDBMS allow for specifying the fields that should be locked by the
FOR UPDATE clause, instead of the full row.

See Also: setForUpdateOf(Field...)
Deprecated: [#5218] - 3.14.0 - Use setForLockModeOf(Collection)/**
     * Some RDBMS allow for specifying the fields that should be locked by the
     * <code>FOR UPDATE</code> clause, instead of the full row.
     * <p>
     *
     * @see #setForUpdateOf(Field...)
     *
     * @deprecated [#5218] - 3.14.0 - Use {@link #setForLockModeOf(Collection)}
     */
    @Deprecated
    @Support({ DERBY, FIREBIRD, H2, HSQLDB })
    void setForUpdateOf(Collection<? extends Field<?>> fields);

    Some RDBMS allow for specifying the tables that should be locked by the
FOR UPDATE clause, instead of the full row.
 This automatically sets the setForUpdate(boolean) flag, and unsets the setForShare(boolean) flag, if it was previously set. 

This has been observed to be natively supported by any of these dialects:

Postgres
H2
HSQLDB
Sybase


jOOQ emulates this by locking all known fields of [tables]
for any of these dialects:

DB2
Derby
Ingres
Oracle

Params: tables – The tables that should be locked
Deprecated: [#5218] - 3.14.0 - Use setForLockModeOf(Table...)/**
     * Some RDBMS allow for specifying the tables that should be locked by the
     * <code>FOR UPDATE</code> clause, instead of the full row.
     * <p>
     * This automatically sets the {@link #setForUpdate(boolean)} flag, and
     * unsets the {@link #setForShare(boolean)} flag, if it was previously set.
     * <p>
     * This has been observed to be natively supported by any of these dialects:
     * <ul>
     * <li>Postgres</li>
     * <li>H2</li>
     * <li>HSQLDB</li>
     * <li>Sybase</li>
     * </ul>
     * <p>
     * jOOQ emulates this by locking all known fields of [<code>tables</code>]
     * for any of these dialects:
     * <ul>
     * <li>DB2</li>
     * <li>Derby</li>
     * <li>Ingres</li>
     * <li>Oracle</li>
     * </ul>
     *
     * @param tables The tables that should be locked
     *
     * @deprecated [#5218] - 3.14.0 - Use {@link #setForLockModeOf(Table...)}
     */
    @Deprecated
    @Support({ DERBY, FIREBIRD, H2, HSQLDB, MYSQL, POSTGRES })
    void setForUpdateOf(Table<?>... tables);

    Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause. In this case, the session will wait for
some seconds, before aborting the lock acquirement if the
lock is not available.
 This automatically sets the setForUpdate(boolean) flag, and unsets the setForShare(boolean) flag, if it was previously set. 

This has been observed to be supported by any of these dialects:

Oracle

Params: seconds – The number of seconds to wait for a lock
Deprecated: [#5218] - 3.14.0 - Use setForLockModeWait(int)/**
     * Some RDBMS allow for specifying the locking mode for the applied
     * <code>FOR UPDATE</code> clause. In this case, the session will wait for
     * some <code>seconds</code>, before aborting the lock acquirement if the
     * lock is not available.
     * <p>
     * This automatically sets the {@link #setForUpdate(boolean)} flag, and
     * unsets the {@link #setForShare(boolean)} flag, if it was previously set.
     * <p>
     * This has been observed to be supported by any of these dialects:
     * <ul>
     * <li>Oracle</li>
     * </ul>
     *
     * @param seconds The number of seconds to wait for a lock
     *
     * @deprecated [#5218] - 3.14.0 - Use {@link #setForLockModeWait(int)}
     */
    @Deprecated
    @Support({ MARIADB })
    void setForUpdateWait(int seconds);

    Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause. In this case, the session will not wait
before aborting the lock acquirement if the lock is not available.
 This automatically sets the setForUpdate(boolean) flag, and unsets the setForShare(boolean) flag, if it was previously set. 

This has been observed to be supported by any of these dialects:

Oracle

Deprecated: [#5218] - 3.14.0 - Use setForLockModeNoWait()/**
     * Some RDBMS allow for specifying the locking mode for the applied
     * <code>FOR UPDATE</code> clause. In this case, the session will not wait
     * before aborting the lock acquirement if the lock is not available.
     * <p>
     * This automatically sets the {@link #setForUpdate(boolean)} flag, and
     * unsets the {@link #setForShare(boolean)} flag, if it was previously set.
     * <p>
     * This has been observed to be supported by any of these dialects:
     * <ul>
     * <li>Oracle</li>
     * </ul>
     *
     * @deprecated [#5218] - 3.14.0 - Use {@link #setForLockModeNoWait()}
     */
    @Deprecated
    @Support({ MARIADB, MYSQL, POSTGRES })
    void setForUpdateNoWait();

    Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause. In this case, the session will skip all
locked rows from the select statement, whose lock is not available.
 This automatically sets the setForUpdate(boolean) flag, and unsets the setForShare(boolean) flag, if it was previously set. 

This has been observed to be supported by any of these dialects:

Oracle

Deprecated: [#5218] - 3.14.0 - Use setForLockModeSkipLocked()/**
     * Some RDBMS allow for specifying the locking mode for the applied
     * <code>FOR UPDATE</code> clause. In this case, the session will skip all
     * locked rows from the select statement, whose lock is not available.
     * <p>
     * This automatically sets the {@link #setForUpdate(boolean)} flag, and
     * unsets the {@link #setForShare(boolean)} flag, if it was previously set.
     * <p>
     * This has been observed to be supported by any of these dialects:
     * <ul>
     * <li>Oracle</li>
     * </ul>
     *
     * @deprecated [#5218] - 3.14.0 - Use {@link #setForLockModeSkipLocked()}
     */
    @Deprecated
    @Support({ MYSQL, POSTGRES })
    void setForUpdateSkipLocked();

    Sets the "FOR SHARE" lock mode onto the query.

This has been observed to be supported by any of these dialects:

MySQL's InnoDB locking reads
Postgres FOR UPDATE / FOR SHARE


If your dialect does not support this clause, jOOQ will still render it,
if you apply it to your query. This might then cause syntax errors
reported either by your database or your JDBC driver.
 You shouldn't combine this with setForUpdate(boolean) 
Params: forShare – The flag's value/**
     * Sets the "FOR SHARE" lock mode onto the query.
     * <p>
     * This has been observed to be supported by any of these dialects:
     * <ul>
     * <li><a
     * href="http://dev.mysql.com/doc/refman/5.5/en/innodb-locking-reads.html"
     * >MySQL's InnoDB locking reads</a></li>
     * <li><a href=
     * "http://www.postgresql.org/docs/9.0/static/sql-select.html#SQL-FOR-UPDATE-SHARE"
     * >Postgres FOR UPDATE / FOR SHARE</a></li>
     * </ul>
     * <p>
     * If your dialect does not support this clause, jOOQ will still render it,
     * if you apply it to your query. This might then cause syntax errors
     * reported either by your database or your JDBC driver.
     * <p>
     * You shouldn't combine this with {@link #setForUpdate(boolean)}
     *
     * @param forShare The flag's value
     */
    @Support({ MARIADB, MYSQL, POSTGRES })
    void setForShare(boolean forShare);

    Sets the "FOR KEY SHARE" lock mode onto the query.
/**
     * Sets the "FOR KEY SHARE" lock mode onto the query.
     */
    @Support({ POSTGRES })
    void setForKeyShare(boolean forKeyShare);

    Some RDBMS allow for specifying the fields that should be locked by the
FOR <lock_mode> clause, instead of the full row.

In case no lock mode has been set yet, it will implicitly be set to
UPDATE (i.e. setForUpdate(boolean)). 

Depending on the dialect and lock mode this flag may or may not be
supported.
 Note, that SQLDialect.DB2 has some stricter requirements regarding the updatability of fields. Refer to the DB2 documentation for further details 
Params: fields – The fields that should be locked/**
     * Some RDBMS allow for specifying the fields that should be locked by the
     * <code>FOR &lt;lock_mode&gt;</code> clause, instead of the full row.
     * <p>
     * In case no lock mode has been set yet, it will implicitly be set to
     * <code>UPDATE</code> (i.e. {@link #setForUpdate(boolean)}).
     * <p>
     * Depending on the dialect and lock mode this flag may or may not be
     * supported.
     * <p>
     * Note, that {@link SQLDialect#DB2} has some stricter requirements
     * regarding the updatability of fields. Refer to the DB2 documentation for
     * further details
     *
     * @param fields The fields that should be locked
     */
    @Support({ DERBY, FIREBIRD, H2, HSQLDB })
    void setForLockModeOf(Field<?>... fields);

    Some RDBMS allow for specifying the fields that should be locked by the
FOR <lock_mode> clause, instead of the full row.

See Also: setForLockModeOf(Field...)/**
     * Some RDBMS allow for specifying the fields that should be locked by the
     * <code>FOR &lt;lock_mode&gt;</code> clause, instead of the full row.
     * <p>
     *
     * @see #setForLockModeOf(Field...)
     */
    @Support({ DERBY, FIREBIRD, H2, HSQLDB })
    void setForLockModeOf(Collection<? extends Field<?>> fields);

    Some RDBMS allow for specifying the tables that should be locked by the
FOR <lock_mode> clause, instead of the full row.

In case no lock mode has been set yet, it will implicitly be set to
UPDATE (i.e. setForUpdate(boolean)). 

Depending on the dialect and lock mode this flag may or may not be
supported.
Params: tables – The tables that should be locked/**
     * Some RDBMS allow for specifying the tables that should be locked by the
     * <code>FOR &lt;lock_mode&gt;</code> clause, instead of the full row.
     * <p>
     * In case no lock mode has been set yet, it will implicitly be set to
     * <code>UPDATE</code> (i.e. {@link #setForUpdate(boolean)}).
     * <p>
     * Depending on the dialect and lock mode this flag may or may not be
     * supported.
     *
     * @param tables The tables that should be locked
     */
    @Support({ DERBY, FIREBIRD, H2, HSQLDB, MYSQL, POSTGRES })
    void setForLockModeOf(Table<?>... tables);

    Some RDBMS allow for specifying the locking mode for the applied
FOR <lock_mode> clause. In this case, the session will
wait for some seconds, before aborting the lock acquirement
if the lock is not available.

In case no lock mode has been set yet, it will implicitly be set to
UPDATE (i.e. setForUpdate(boolean)). 

Depending on the dialect and lock mode this flag may or may not be
supported.
Params: seconds – The number of seconds to wait for a lock/**
     * Some RDBMS allow for specifying the locking mode for the applied
     * <code>FOR &lt;lock_mode&gt;</code> clause. In this case, the session will
     * wait for some <code>seconds</code>, before aborting the lock acquirement
     * if the lock is not available.
     * <p>
     * In case no lock mode has been set yet, it will implicitly be set to
     * <code>UPDATE</code> (i.e. {@link #setForUpdate(boolean)}).
     * <p>
     * Depending on the dialect and lock mode this flag may or may not be
     * supported.
     *
     * @param seconds The number of seconds to wait for a lock
     */
    @Support({ MARIADB })
    void setForLockModeWait(int seconds);

    Some RDBMS allow for specifying the locking mode for the applied
FOR <lock_mode> clause. In this case, the session will
not wait before aborting the lock acquirement if the lock is not
available.

In case no lock mode has been set yet, it will implicitly be set to
UPDATE (i.e. setForUpdate(boolean)). 

Depending on the dialect and lock mode this flag may or may not be
supported.
/**
     * Some RDBMS allow for specifying the locking mode for the applied
     * <code>FOR &lt;lock_mode&gt;</code> clause. In this case, the session will
     * not wait before aborting the lock acquirement if the lock is not
     * available.
     * <p>
     * In case no lock mode has been set yet, it will implicitly be set to
     * <code>UPDATE</code> (i.e. {@link #setForUpdate(boolean)}).
     * <p>
     * Depending on the dialect and lock mode this flag may or may not be
     * supported.
     */
    @Support({ MARIADB, MYSQL, POSTGRES })
    void setForLockModeNoWait();

    Some RDBMS allow for specifying the locking mode for the applied
FOR <lock_mode> clause. In this case, the session will
skip all locked rows from the select statement, whose lock is not
available.

In case no lock mode has been set yet, it will implicitly be set to
UPDATE (i.e. setForUpdate(boolean)). 

Depending on the dialect and lock mode this flag may or may not be
supported.
/**
     * Some RDBMS allow for specifying the locking mode for the applied
     * <code>FOR &lt;lock_mode&gt;</code> clause. In this case, the session will
     * skip all locked rows from the select statement, whose lock is not
     * available.
     * <p>
     * In case no lock mode has been set yet, it will implicitly be set to
     * <code>UPDATE</code> (i.e. {@link #setForUpdate(boolean)}).
     * <p>
     * Depending on the dialect and lock mode this flag may or may not be
     * supported.
     */
    @Support({ MYSQL, POSTGRES })
    void setForLockModeSkipLocked();




























































































































}
Params:	table – The joined table type – The type of join
Throws:	DataAccessException – If there is no non-ambiguous key definition known to jOOQ
See Also:	TableOnStep.onKey(ForeignKey)
Params:	fields – The seeking fields
Deprecated:	- [#7461] - SEEK BEFORE is not implemented correctly
Params:	fields – The fields that should be locked
Deprecated:	[#5218] - 3.14.0 - Use `setForLockModeOf(Field...)`
See Also:	setForUpdateOf(Field...)
Deprecated:	[#5218] - 3.14.0 - Use `setForLockModeOf(Collection)`
Params:	tables – The tables that should be locked
Deprecated:	[#5218] - 3.14.0 - Use `setForLockModeOf(Table...)`
Params:	seconds – The number of seconds to wait for a lock
Deprecated:	[#5218] - 3.14.0 - Use `setForLockModeWait(int)`
/

org.jooq/ jooq/ 3.14.7/ org/jooq/SelectQuery.java

Native implementation

Emulation

Not supported
