org.jooq/jooq/3.14.7 : org/jooq/Table.java

Table
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.sql.Timestamp;
import java.util.Collection;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;

import org.jooq.TableOptions.TableType;
import org.jooq.conf.Settings;
import org.jooq.impl.DSL;

import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

A table.
 Like Field, a Table is a basic building block of any Query, as they all operate on at least one table. There are many different types of tables, including: 


Generated table references
Plain SQL tables created with DSL.table(String)
Table references created with DSL.table(Name)
Derived tables created with DSL.table(Select<Record>)
Join expressions created e.g. with join(TableLike)
Common table expressions (CommonTableExpression)
Unnested arrays referenced through DSL.unnest(Field<?>) and overloads
Table valued functions as provided by the code generator
Etc.


Example:

// Assuming import static org.jooq.impl.DSL.*;
using(configuration)
   .select(ACTOR.FIRST_NAME, ACTOR.LAST_NAME)
   .from(ACTOR) // Table reference
   .fetch();

 Instances can be created using DSL.table(Name) and overloads. 
Author: Lukas Eder
Type parameters: <R> – The record type associated with this table/**
 * A table.
 * <p>
 * Like {@link Field}, a {@link Table} is a basic building block of any
 * {@link Query}, as they all operate on at least one table. There are many
 * different types of tables, including:
 * <p>
 * <ul>
 * <li>Generated table references</li>
 * <li>Plain SQL tables created with {@link DSL#table(String)}</li>
 * <li>Table references created with {@link DSL#table(Name)}</li>
 * <li>Derived tables created with {@link DSL#table(Select)}</li>
 * <li>Join expressions created e.g. with {@link Table#join(TableLike)}</li>
 * <li>Common table expressions ({@link CommonTableExpression})</li>
 * <li>Unnested arrays referenced through {@link DSL#unnest(Field)} and
 * overloads</li>
 * <li>Table valued functions as provided by the code generator</li>
 * <li>Etc.</li>
 * </ul>
 * <p>
 * <strong>Example:</strong>
 * <p>
 * <code><pre>
 * // Assuming import static org.jooq.impl.DSL.*;
 *
 * using(configuration)
 *    .select(ACTOR.FIRST_NAME, ACTOR.LAST_NAME)
 *    .from(ACTOR) // Table reference
 *    .fetch();
 * </pre></code>
 * <p>
 * Instances can be created using {@link DSL#table(Name)} and overloads.
 *
 * @param <R> The record type associated with this table
 * @author Lukas Eder
 */
public interface Table<R extends Record> extends TableLike<R>, Qualified {

    Get the table type.
/**
     * Get the table type.
     */
    @NotNull
    TableType getType();

    Get the table options.
/**
     * Get the table options.
     */
    @NotNull
    TableOptions getOptions();

    The record type produced by this table.
/**
     * The record type produced by this table.
     */
    @NotNull
    RecordType<R> recordType();

    The record type produced by this table.
/**
     * The record type produced by this table.
     */
    @NotNull
    Class<? extends R> getRecordType();

    The table's record type as a UDT data type, in case the underlying
database supports table records as UDT records.
/**
     * The table's record type as a UDT data type, in case the underlying
     * database supports table records as UDT records.
     */
    @NotNull
    DataType<R> getDataType();

    Create a new Record of this table's type. 
See Also: DSLContext.newRecord(Table<Record>)/**
     * Create a new {@link Record} of this table's type.
     *
     * @see DSLContext#newRecord(Table)
     */
    @NotNull
    R newRecord();

    Retrieve the table's IDENTITY information, if available.

With SQL:2003, the concept of IDENTITY columns was
introduced in most RDBMS. These are special kinds of columns that have
auto-increment functionality when INSERT statements are
performed.

An IDENTITY column is usually part of the
PRIMARY KEY or of a UNIQUE KEY in the table,
although in some RDBMS, this is not required. There can only be at most
one IDENTITY column.

Note: Unfortunately, this is not supported in the Oracle dialect, where
identities emulated by triggers cannot be formally detected.
Returns: The table's IDENTITY information, or
        null, if no such information is available./**
     * Retrieve the table's <code>IDENTITY</code> information, if available.
     * <p>
     * With SQL:2003, the concept of <code>IDENTITY</code> columns was
     * introduced in most RDBMS. These are special kinds of columns that have
     * auto-increment functionality when <code>INSERT</code> statements are
     * performed.
     * <p>
     * An <code>IDENTITY</code> column is usually part of the
     * <code>PRIMARY KEY</code> or of a <code>UNIQUE KEY</code> in the table,
     * although in some RDBMS, this is not required. There can only be at most
     * one <code>IDENTITY</code> column.
     * <p>
     * Note: Unfortunately, this is not supported in the Oracle dialect, where
     * identities emulated by triggers cannot be formally detected.
     *
     * @return The table's <code>IDENTITY</code> information, or
     *         <code>null</code>, if no such information is available.
     */
    @Nullable
    Identity<R, ?> getIdentity();

    Retrieve the table's primary key
Returns: The primary key. This is never null for an updatable
        table./**
     * Retrieve the table's primary key
     *
     * @return The primary key. This is never <code>null</code> for an updatable
     *         table.
     */
    @Nullable
    UniqueKey<R> getPrimaryKey();

    A "version" field holding record version information used for optimistic
locking
 jOOQ supports optimistic locking in UpdatableRecord.store() and UpdatableRecord.delete() if Settings.isExecuteWithOptimisticLocking() is enabled. Optimistic locking is performed in a single UPDATE or
DELETE statement if tables provide a "version" or
"timestamp" field, or in two steps using an additional
SELECT .. FOR UPDATE statement otherwise.

This method is overridden in generated subclasses if their corresponding
tables have been configured accordingly. A table may have both a
"version" and a "timestamp" field.
See Also: getRecordTimestamp()
UpdatableRecord.store()
UpdatableRecord.delete()
Settings.isExecuteWithOptimisticLocking()
Returns: The "version" field, or null, if this table has no
        "version" field./**
     * A "version" field holding record version information used for optimistic
     * locking
     * <p>
     * jOOQ supports optimistic locking in {@link UpdatableRecord#store()} and
     * {@link UpdatableRecord#delete()} if
     * {@link Settings#isExecuteWithOptimisticLocking()} is enabled. Optimistic
     * locking is performed in a single <code>UPDATE</code> or
     * <code>DELETE</code> statement if tables provide a "version" or
     * "timestamp" field, or in two steps using an additional
     * <code>SELECT .. FOR UPDATE</code> statement otherwise.
     * <p>
     * This method is overridden in generated subclasses if their corresponding
     * tables have been configured accordingly. A table may have both a
     * "version" and a "timestamp" field.
     *
     * @return The "version" field, or <code>null</code>, if this table has no
     *         "version" field.
     * @see #getRecordTimestamp()
     * @see UpdatableRecord#store()
     * @see UpdatableRecord#delete()
     * @see Settings#isExecuteWithOptimisticLocking()
     */
    @Nullable
    TableField<R, ?> getRecordVersion();

    A "timestamp" field holding record timestamp information used for
optimistic locking
 jOOQ supports optimistic locking in UpdatableRecord.store() and UpdatableRecord.delete() if Settings.isExecuteWithOptimisticLocking() is enabled. Optimistic locking is performed in a single UPDATE or
DELETE statement if tables provide a "version" or
"timestamp" field, or in two steps using an additional
SELECT .. FOR UPDATE statement otherwise.

This method is overridden in generated subclasses if their corresponding
tables have been configured accordingly. A table may have both a
"version" and a "timestamp" field.
See Also: getRecordVersion()
UpdatableRecord.store()
UpdatableRecord.delete()
Settings.isExecuteWithOptimisticLocking()
Returns: The "timestamp" field, or null, if this table has no
        "timestamp" field./**
     * A "timestamp" field holding record timestamp information used for
     * optimistic locking
     * <p>
     * jOOQ supports optimistic locking in {@link UpdatableRecord#store()} and
     * {@link UpdatableRecord#delete()} if
     * {@link Settings#isExecuteWithOptimisticLocking()} is enabled. Optimistic
     * locking is performed in a single <code>UPDATE</code> or
     * <code>DELETE</code> statement if tables provide a "version" or
     * "timestamp" field, or in two steps using an additional
     * <code>SELECT .. FOR UPDATE</code> statement otherwise.
     * <p>
     * This method is overridden in generated subclasses if their corresponding
     * tables have been configured accordingly. A table may have both a
     * "version" and a "timestamp" field.
     *
     * @return The "timestamp" field, or <code>null</code>, if this table has no
     *         "timestamp" field.
     * @see #getRecordVersion()
     * @see UpdatableRecord#store()
     * @see UpdatableRecord#delete()
     * @see Settings#isExecuteWithOptimisticLocking()
     */
    @Nullable
    TableField<R, ?> getRecordTimestamp();

    Retrieve all of the table's indexes.
Returns: All indexes. This is never null. This method returns
        an unmodifiable list./**
     * Retrieve all of the table's indexes.
     *
     * @return All indexes. This is never <code>null</code>. This method returns
     *         an unmodifiable list.
     */
    @NotNull
    List<Index> getIndexes();

    Retrieve all of the table's unique keys.
Returns: All keys. This is never null. This is never empty for a Table with a getPrimaryKey(). This method returns an unmodifiable list./**
     * Retrieve all of the table's unique keys.
     *
     * @return All keys. This is never <code>null</code>. This is never empty
     *         for a {@link Table} with a {@link Table#getPrimaryKey()}. This
     *         method returns an unmodifiable list.
     */
    @NotNull
    List<UniqueKey<R>> getKeys();

    Get a list of FOREIGN KEY's of a specific table, referencing
a this table.

This will recurse into joined tables.
Params: other – The other table of the foreign key relationship
Type parameters: <O> – The other table's record type
Returns: Some other table's FOREIGN KEY's towards an this
        table. This is never null. This method returns an
        unmodifiable list./**
     * Get a list of <code>FOREIGN KEY</code>'s of a specific table, referencing
     * a this table.
     * <p>
     * This will recurse into joined tables.
     *
     * @param <O> The other table's record type
     * @param other The other table of the foreign key relationship
     * @return Some other table's <code>FOREIGN KEY</code>'s towards an this
     *         table. This is never <code>null</code>. This method returns an
     *         unmodifiable list.
     */
    @NotNull
    <O extends Record> List<ForeignKey<O, R>> getReferencesFrom(Table<O> other);

    Get the list of FOREIGN KEY's of this table
Returns: This table's FOREIGN KEY's. This is never
        null./**
     * Get the list of <code>FOREIGN KEY</code>'s of this table
     *
     * @return This table's <code>FOREIGN KEY</code>'s. This is never
     *         <code>null</code>.
     */
    @NotNull
    List<ForeignKey<R, ?>> getReferences();

    Get a list of FOREIGN KEY's of this table, referencing a
specific table.

This will recurse into joined tables.
Params: other – The other table of the foreign key relationship
Type parameters: <O> – The other table's record type
Returns: This table's FOREIGN KEY's towards an other table.
        This is never null./**
     * Get a list of <code>FOREIGN KEY</code>'s of this table, referencing a
     * specific table.
     * <p>
     * This will recurse into joined tables.
     *
     * @param <O> The other table's record type
     * @param other The other table of the foreign key relationship
     * @return This table's <code>FOREIGN KEY</code>'s towards an other table.
     *         This is never <code>null</code>.
     */
    @NotNull
    <O extends Record> List<ForeignKey<R, O>> getReferencesTo(Table<O> other);

    Get a list of CHECK constraints of this table.
/**
     * Get a list of <code>CHECK</code> constraints of this table.
     */
    @NotNull
    List<Check<R>> getChecks();




































    // -------------------------------------------------------------------------
    // XXX: Expressions based on this table
    // -------------------------------------------------------------------------

    Create a qualified asterisk expression from this table
(table.*) for use with SELECT.
See Also: asterisk.asterisk()/**
     * Create a qualified asterisk expression from this table
     * (<code>table.*</code>) for use with <code>SELECT</code>.
     *
     * @see DSL#asterisk()
     */
    @NotNull
    @Support
    QualifiedAsterisk asterisk();

    Get a table.rowid reference from this table.

A rowid value describes the physical location of a row on the disk, which
can be used as a replacement for a primary key in some situations -
especially within a query, e.g. to self-join a table:

-- Emulating this MySQL statement...
DELETE FROM x ORDER BY x.y LIMIT 1
-- ... in other databases
DELETE FROM x
WHERE x.rowid IN (
  SELECT x.rowid FROM x ORDER BY x.a LIMIT 1
)


It is not recommended to use rowid values in client
applications as actual row identifiers as the database system may move a
row to a different physical location at any time, thus changing the rowid
value. In general, use primary keys, instead.
/**
     * Get a <code>table.rowid</code> reference from this table.
     * <p>
     * A rowid value describes the physical location of a row on the disk, which
     * can be used as a replacement for a primary key in some situations -
     * especially within a query, e.g. to self-join a table:
     * <p>
     * <code><pre>
     * -- Emulating this MySQL statement...
     * DELETE FROM x ORDER BY x.y LIMIT 1
     *
     * -- ... in other databases
     * DELETE FROM x
     * WHERE x.rowid IN (
     *   SELECT x.rowid FROM x ORDER BY x.a LIMIT 1
     * )
     * </pre></code>
     * <p>
     * It is <em>not</em> recommended to use <code>rowid</code> values in client
     * applications as actual row identifiers as the database system may move a
     * row to a different physical location at any time, thus changing the rowid
     * value. In general, use primary keys, instead.
     */
    @NotNull
    @Support({ H2, POSTGRES, SQLITE })
    Field<RowId> rowid();

    // -------------------------------------------------------------------------
    // XXX: Aliasing clauses
    // -------------------------------------------------------------------------

    Create an alias for this table.
 Note that the case-sensitivity of the returned table depends on Settings.getRenderQuotedNames(). By default, table aliases are quoted, and thus case-sensitive in many SQL dialects! 
Params: alias – The alias name
Returns: The table alias/**
     * Create an alias for this table.
     * <p>
     * Note that the case-sensitivity of the returned table depends on
     * {@link Settings#getRenderQuotedNames()}. By default, table aliases are
     * quoted, and thus case-sensitive in many SQL dialects!
     *
     * @param alias The alias name
     * @return The table alias
     */
    @NotNull
    @Support
    Table<R> as(String alias);

    Create an alias for this table and its fields.
 Note that the case-sensitivity of the returned table and columns depends on Settings.getRenderQuotedNames(). By default, table aliases are quoted, and thus case-sensitive in many SQL dialects! 

Derived column lists for table references

Note, not all databases support derived column lists for their table
aliases. On the other hand, some databases do support derived column
lists, but only for derived tables. jOOQ will try to turn table
references into derived tables to make this syntax work. In other words,
the following statements are equivalent: 
-- Using derived column lists to rename columns (e.g. Postgres)
SELECT t.a, t.b
FROM my_table t(a, b)
-- Nesting table references within derived tables (e.g. SQL Server)
SELECT t.a, t.b
FROM (
  SELECT * FROM my_table
) t(a, b)


Derived column lists for derived tables

Other databases may not support derived column lists at all, but they do
support common table expressions. The following statements are
equivalent: 
-- Using derived column lists to rename columns (e.g. Postgres)
SELECT t.a, t.b
FROM (
  SELECT 1, 2
) AS t(a, b)
-- Using UNION ALL to produce column names (e.g. MySQL)
SELECT t.a, t.b
FROM (
  SELECT null a, null b FROM DUAL WHERE 1 = 0
  UNION ALL
  SELECT 1, 2 FROM DUAL
) t

Params: alias – The alias name
fieldAliases – The field aliases. Excess aliases are ignored,
           missing aliases will be substituted by this table's field
           names.
Returns: The table alias/**
     * Create an alias for this table and its fields.
     * <p>
     * Note that the case-sensitivity of the returned table and columns depends
     * on {@link Settings#getRenderQuotedNames()}. By default, table aliases are
     * quoted, and thus case-sensitive in many SQL dialects!
     * <p>
     * <h5>Derived column lists for table references</h5>
     * <p>
     * Note, not all databases support derived column lists for their table
     * aliases. On the other hand, some databases do support derived column
     * lists, but only for derived tables. jOOQ will try to turn table
     * references into derived tables to make this syntax work. In other words,
     * the following statements are equivalent: <code><pre>
     * -- Using derived column lists to rename columns (e.g. Postgres)
     * SELECT t.a, t.b
     * FROM my_table t(a, b)
     *
     * -- Nesting table references within derived tables (e.g. SQL Server)
     * SELECT t.a, t.b
     * FROM (
     *   SELECT * FROM my_table
     * ) t(a, b)
     * </pre></code>
     * <p>
     * <h5>Derived column lists for derived tables</h5>
     * <p>
     * Other databases may not support derived column lists at all, but they do
     * support common table expressions. The following statements are
     * equivalent: <code><pre>
     * -- Using derived column lists to rename columns (e.g. Postgres)
     * SELECT t.a, t.b
     * FROM (
     *   SELECT 1, 2
     * ) AS t(a, b)
     *
     * -- Using UNION ALL to produce column names (e.g. MySQL)
     * SELECT t.a, t.b
     * FROM (
     *   SELECT null a, null b FROM DUAL WHERE 1 = 0
     *   UNION ALL
     *   SELECT 1, 2 FROM DUAL
     * ) t
     * </pre></code>
     *
     * @param alias The alias name
     * @param fieldAliases The field aliases. Excess aliases are ignored,
     *            missing aliases will be substituted by this table's field
     *            names.
     * @return The table alias
     */
    @NotNull
    @Support
    Table<R> as(String alias, String... fieldAliases);


    Create an alias for this table and its fields.
 This works like as(String, String...), except that field aliases are provided by a function. This is useful, for instance, to prefix all columns with a common prefix: 

MY_TABLE.as("t1", f ->"prefix_" + f.getName());

Params: alias – The alias name
aliasFunction – The function providing field aliases.
Returns: The table alias
Deprecated: - 3.14.0 - [#10156] - These methods will be removed without
            replacement from a future jOOQ. They offer convenience that
            is unidiomatic for jOOQ's DSL, without offering functionality
            that would not be possible otherwise - yet they add
            complexity in jOOQ's internals./**
     * Create an alias for this table and its fields.
     * <p>
     * This works like {@link #as(String, String...)}, except that field aliases
     * are provided by a function. This is useful, for instance, to prefix all
     * columns with a common prefix:
     * <p>
     * <code><pre>
     * MY_TABLE.as("t1", f -&gt;"prefix_" + f.getName());
     * </pre></code>
     *
     * @param alias The alias name
     * @param aliasFunction The function providing field aliases.
     * @return The table alias
     * @deprecated - 3.14.0 - [#10156] - These methods will be removed without
     *             replacement from a future jOOQ. They offer convenience that
     *             is unidiomatic for jOOQ's DSL, without offering functionality
     *             that would not be possible otherwise - yet they add
     *             complexity in jOOQ's internals.
     */
    @Deprecated
    @NotNull
    @Support
    Table<R> as(String alias, Function<? super Field<?>, ? extends String> aliasFunction);

    Create an alias for this table and its fields.
 This works like as(String, String...), except that field aliases are provided by a function. This is useful, for instance, to prefix all columns with a common prefix: 

MY_TABLE.as("t1", (f, i) ->"column" + i);

Params: alias – The alias name
aliasFunction – The function providing field aliases.
Returns: The table alias
Deprecated: - 3.14.0 - [#10156] - These methods will be removed without
            replacement from a future jOOQ. They offer convenience that
            is unidiomatic for jOOQ's DSL, without offering functionality
            that would not be possible otherwise - yet they add
            complexity in jOOQ's internals./**
     * Create an alias for this table and its fields.
     * <p>
     * This works like {@link #as(String, String...)}, except that field aliases
     * are provided by a function. This is useful, for instance, to prefix all
     * columns with a common prefix:
     * <p>
     * <code><pre>
     * MY_TABLE.as("t1", (f, i) -&gt;"column" + i);
     * </pre></code>
     *
     * @param alias The alias name
     * @param aliasFunction The function providing field aliases.
     * @return The table alias
     * @deprecated - 3.14.0 - [#10156] - These methods will be removed without
     *             replacement from a future jOOQ. They offer convenience that
     *             is unidiomatic for jOOQ's DSL, without offering functionality
     *             that would not be possible otherwise - yet they add
     *             complexity in jOOQ's internals.
     */
    @Deprecated
    @NotNull
    @Support
    Table<R> as(String alias, BiFunction<? super Field<?>, ? super Integer, ? extends String> aliasFunction);


    Create an alias for this table.
 Note that the case-sensitivity of the returned table depends on Settings.getRenderQuotedNames() and the Name. By default, table aliases are quoted, and thus case-sensitive in many SQL dialects - use DSL.unquotedName(String...) for case-insensitive aliases. 
 If the argument Name.getName() is qualified, then the Name.last() part will be used. 
Params: alias – The alias name
Returns: The table alias/**
     * Create an alias for this table.
     * <p>
     * Note that the case-sensitivity of the returned table depends on
     * {@link Settings#getRenderQuotedNames()} and the {@link Name}. By default,
     * table aliases are quoted, and thus case-sensitive in many SQL dialects -
     * use {@link DSL#unquotedName(String...)} for case-insensitive aliases.
     * <p>
     * If the argument {@link Name#getName()} is qualified, then the
     * {@link Name#last()} part will be used.
     *
     * @param alias The alias name
     * @return The table alias
     */
    @NotNull
    @Support
    Table<R> as(Name alias);

    Create an alias for this table and its fields.
 Note that the case-sensitivity of the returned table depends on Settings.getRenderQuotedNames() and the Name. By default, table aliases are quoted, and thus case-sensitive in many SQL dialects - use DSL.unquotedName(String...) for case-insensitive aliases. 
 If the argument Name.getName() is qualified, then the Name.last() part will be used. 

Derived column lists for table references

Note, not all databases support derived column lists for their table
aliases. On the other hand, some databases do support derived column
lists, but only for derived tables. jOOQ will try to turn table
references into derived tables to make this syntax work. In other words,
the following statements are equivalent: 
-- Using derived column lists to rename columns (e.g. Postgres)
SELECT t.a, t.b
FROM my_table t(a, b)
-- Nesting table references within derived tables (e.g. SQL Server)
SELECT t.a, t.b
FROM (
  SELECT * FROM my_table
) t(a, b)


Derived column lists for derived tables

Other databases may not support derived column lists at all, but they do
support common table expressions. The following statements are
equivalent: 
-- Using derived column lists to rename columns (e.g. Postgres)
SELECT t.a, t.b
FROM (
  SELECT 1, 2
) AS t(a, b)
-- Using UNION ALL to produce column names (e.g. MySQL)
SELECT t.a, t.b
FROM (
  SELECT null a, null b FROM DUAL WHERE 1 = 0
  UNION ALL
  SELECT 1, 2 FROM DUAL
) t

Params: alias – The alias name
fieldAliases – The field aliases. Excess aliases are ignored,
           missing aliases will be substituted by this table's field
           names.
Returns: The table alias/**
     * Create an alias for this table and its fields.
     * <p>
     * Note that the case-sensitivity of the returned table depends on
     * {@link Settings#getRenderQuotedNames()} and the {@link Name}. By default,
     * table aliases are quoted, and thus case-sensitive in many SQL dialects -
     * use {@link DSL#unquotedName(String...)} for case-insensitive aliases.
     * <p>
     * If the argument {@link Name#getName()} is qualified, then the
     * {@link Name#last()} part will be used.
     * <p>
     * <h5>Derived column lists for table references</h5>
     * <p>
     * Note, not all databases support derived column lists for their table
     * aliases. On the other hand, some databases do support derived column
     * lists, but only for derived tables. jOOQ will try to turn table
     * references into derived tables to make this syntax work. In other words,
     * the following statements are equivalent: <code><pre>
     * -- Using derived column lists to rename columns (e.g. Postgres)
     * SELECT t.a, t.b
     * FROM my_table t(a, b)
     *
     * -- Nesting table references within derived tables (e.g. SQL Server)
     * SELECT t.a, t.b
     * FROM (
     *   SELECT * FROM my_table
     * ) t(a, b)
     * </pre></code>
     * <p>
     * <h5>Derived column lists for derived tables</h5>
     * <p>
     * Other databases may not support derived column lists at all, but they do
     * support common table expressions. The following statements are
     * equivalent: <code><pre>
     * -- Using derived column lists to rename columns (e.g. Postgres)
     * SELECT t.a, t.b
     * FROM (
     *   SELECT 1, 2
     * ) AS t(a, b)
     *
     * -- Using UNION ALL to produce column names (e.g. MySQL)
     * SELECT t.a, t.b
     * FROM (
     *   SELECT null a, null b FROM DUAL WHERE 1 = 0
     *   UNION ALL
     *   SELECT 1, 2 FROM DUAL
     * ) t
     * </pre></code>
     *
     * @param alias The alias name
     * @param fieldAliases The field aliases. Excess aliases are ignored,
     *            missing aliases will be substituted by this table's field
     *            names.
     * @return The table alias
     */
    @NotNull
    @Support
    Table<R> as(Name alias, Name... fieldAliases);


    Create an alias for this table and its fields.
 This works like as(Name, Name...), except that field aliases are provided by a function. This is useful, for instance, to prefix all columns with a common prefix: 

MY_TABLE.as("t1", f ->"prefix_" + f.getName());

Params: alias – The alias name
aliasFunction – The function providing field aliases.
Returns: The table alias
Deprecated: - 3.14.0 - [#10156] - These methods will be removed without
            replacement from a future jOOQ. They offer convenience that
            is unidiomatic for jOOQ's DSL, without offering functionality
            that would not be possible otherwise - yet they add
            complexity in jOOQ's internals./**
     * Create an alias for this table and its fields.
     * <p>
     * This works like {@link #as(Name, Name...)}, except that field aliases
     * are provided by a function. This is useful, for instance, to prefix all
     * columns with a common prefix:
     * <p>
     * <code><pre>
     * MY_TABLE.as("t1", f -&gt;"prefix_" + f.getName());
     * </pre></code>
     *
     * @param alias The alias name
     * @param aliasFunction The function providing field aliases.
     * @return The table alias
     * @deprecated - 3.14.0 - [#10156] - These methods will be removed without
     *             replacement from a future jOOQ. They offer convenience that
     *             is unidiomatic for jOOQ's DSL, without offering functionality
     *             that would not be possible otherwise - yet they add
     *             complexity in jOOQ's internals.
     */
    @Deprecated
    @NotNull
    @Support
    Table<R> as(Name alias, Function<? super Field<?>, ? extends Name> aliasFunction);

    Create an alias for this table and its fields.
 This works like as(Name, Name...), except that field aliases are provided by a function. This is useful, for instance, to prefix all columns with a common prefix: 

MY_TABLE.as("t1", (f, i) ->"column" + i);

Params: alias – The alias name
aliasFunction – The function providing field aliases.
Returns: The table alias
Deprecated: - 3.14.0 - [#10156] - These methods will be removed without
            replacement from a future jOOQ. They offer convenience that
            is unidiomatic for jOOQ's DSL, without offering functionality
            that would not be possible otherwise - yet they add
            complexity in jOOQ's internals./**
     * Create an alias for this table and its fields.
     * <p>
     * This works like {@link #as(Name, Name...)}, except that field aliases
     * are provided by a function. This is useful, for instance, to prefix all
     * columns with a common prefix:
     * <p>
     * <code><pre>
     * MY_TABLE.as("t1", (f, i) -&gt;"column" + i);
     * </pre></code>
     *
     * @param alias The alias name
     * @param aliasFunction The function providing field aliases.
     * @return The table alias
     * @deprecated - 3.14.0 - [#10156] - These methods will be removed without
     *             replacement from a future jOOQ. They offer convenience that
     *             is unidiomatic for jOOQ's DSL, without offering functionality
     *             that would not be possible otherwise - yet they add
     *             complexity in jOOQ's internals.
     */
    @Deprecated
    @NotNull
    @Support
    Table<R> as(Name alias, BiFunction<? super Field<?>, ? super Integer, ? extends Name> aliasFunction);


    Create an alias for this table based on another table's name.
Params: otherTable – The other table whose name this table is aliased with.
Returns: The table alias./**
     * Create an alias for this table based on another table's name.
     *
     * @param otherTable The other table whose name this table is aliased with.
     * @return The table alias.
     */
    @NotNull
    @Support
    Table<R> as(Table<?> otherTable);

    Create an alias for this table based on another table's name.
Params: otherTable – The other table whose name this table is aliased with.
otherFields – The other fields whose field name this table's fields
           are aliased with.
Returns: The table alias./**
     * Create an alias for this table based on another table's name.
     *
     * @param otherTable The other table whose name this table is aliased with.
     * @param otherFields The other fields whose field name this table's fields
     *            are aliased with.
     * @return The table alias.
     */
    @NotNull
    @Support
    Table<R> as(Table<?> otherTable, Field<?>... otherFields);


    Create an alias for this table and its fields.
 This works like as(Table, Field...), except that field aliases are provided by a function. This is useful, for instance, to prefix all columns with a common prefix: 

MY_TABLE.as(MY_OTHER_TABLE, f ->MY_OTHER_TABLE.field(f));

Params: otherTable – The other table whose name is used as alias name
aliasFunction – The function providing field aliases.
Returns: The table alias
Deprecated: - 3.14.0 - [#10156] - These methods will be removed without
            replacement from a future jOOQ. They offer convenience that
            is unidiomatic for jOOQ's DSL, without offering functionality
            that would not be possible otherwise - yet they add
            complexity in jOOQ's internals./**
     * Create an alias for this table and its fields.
     * <p>
     * This works like {@link #as(Table, Field...)}, except that field aliases
     * are provided by a function. This is useful, for instance, to prefix all
     * columns with a common prefix:
     * <p>
     * <code><pre>
     * MY_TABLE.as(MY_OTHER_TABLE, f -&gt;MY_OTHER_TABLE.field(f));
     * </pre></code>
     *
     * @param otherTable The other table whose name is used as alias name
     * @param aliasFunction The function providing field aliases.
     * @return The table alias
     * @deprecated - 3.14.0 - [#10156] - These methods will be removed without
     *             replacement from a future jOOQ. They offer convenience that
     *             is unidiomatic for jOOQ's DSL, without offering functionality
     *             that would not be possible otherwise - yet they add
     *             complexity in jOOQ's internals.
     */
    @Deprecated
    @NotNull
    @Support
    Table<R> as(Table<?> otherTable, Function<? super Field<?>, ? extends Field<?>> aliasFunction);

    Create an alias for this table and its fields.
 This works like as(Table, Field...), except that field aliases are provided by a function. This is useful, for instance, to prefix all columns with a common prefix: 

MY_TABLE.as("t1", (f, i) ->"column" + i);

Params: otherTable – The other table whose name is used as alias name
aliasFunction – The function providing field aliases.
Returns: The table alias
Deprecated: - 3.14.0 - [#10156] - These methods will be removed without
            replacement from a future jOOQ. They offer convenience that
            is unidiomatic for jOOQ's DSL, without offering functionality
            that would not be possible otherwise - yet they add
            complexity in jOOQ's internals./**
     * Create an alias for this table and its fields.
     * <p>
     * This works like {@link #as(Table, Field...)}, except that field aliases
     * are provided by a function. This is useful, for instance, to prefix all
     * columns with a common prefix:
     * <p>
     * <code><pre>
     * MY_TABLE.as("t1", (f, i) -&gt;"column" + i);
     * </pre></code>
     *
     * @param otherTable The other table whose name is used as alias name
     * @param aliasFunction The function providing field aliases.
     * @return The table alias
     * @deprecated - 3.14.0 - [#10156] - These methods will be removed without
     *             replacement from a future jOOQ. They offer convenience that
     *             is unidiomatic for jOOQ's DSL, without offering functionality
     *             that would not be possible otherwise - yet they add
     *             complexity in jOOQ's internals.
     */
    @Deprecated
    @NotNull
    @Support
    Table<R> as(Table<?> otherTable, BiFunction<? super Field<?>, ? super Integer, ? extends Field<?>> aliasFunction);


    // -------------------------------------------------------------------------
    // XXX: WHERE clauses on tables
    // -------------------------------------------------------------------------

    Add a WHERE clause to the table, connecting them with each other with Operator.AND.  The resulting table acts like a derived table that projects all of this table's columns and filters by the argument Condition. If syntactically reasonable, the derived table may be inlined to the query that selects from the resulting table. /**
     * Add a <code>WHERE</code> clause to the table, connecting them with each
     * other with {@link Operator#AND}.
     * <p>
     * The resulting table acts like a derived table that projects all of this
     * table's columns and filters by the argument {@link Condition}. If
     * syntactically reasonable, the derived table may be inlined to the query
     * that selects from the resulting table.
     */
    @NotNull
    @Support
    Table<R> where(Condition condition);

    Add a WHERE clause to the table, connecting them with each other with Operator.AND.  The resulting table acts like a derived table that projects all of this table's columns and filters by the argument Condition. If syntactically reasonable, the derived table may be inlined to the query that selects from the resulting table. /**
     * Add a <code>WHERE</code> clause to the table, connecting them with each
     * other with {@link Operator#AND}.
     * <p>
     * The resulting table acts like a derived table that projects all of this
     * table's columns and filters by the argument {@link Condition}. If
     * syntactically reasonable, the derived table may be inlined to the query
     * that selects from the resulting table.
     */
    @NotNull
    @Support
    Table<R> where(Condition... conditions);

    Add a WHERE clause to the table, connecting them with each other with Operator.AND.  The resulting table acts like a derived table that projects all of this table's columns and filters by the argument Condition. If syntactically reasonable, the derived table may be inlined to the query that selects from the resulting table. /**
     * Add a <code>WHERE</code> clause to the table, connecting them with each
     * other with {@link Operator#AND}.
     * <p>
     * The resulting table acts like a derived table that projects all of this
     * table's columns and filters by the argument {@link Condition}. If
     * syntactically reasonable, the derived table may be inlined to the query
     * that selects from the resulting table.
     */
    @NotNull
    @Support
    Table<R> where(Collection<? extends Condition> conditions);

    Add a WHERE clause to the table.
 The resulting table acts like a derived table that projects all of this table's columns and filters by the argument Condition. If syntactically reasonable, the derived table may be inlined to the query that selects from the resulting table. /**
     * Add a <code>WHERE</code> clause to the table.
     * <p>
     * The resulting table acts like a derived table that projects all of this
     * table's columns and filters by the argument {@link Condition}. If
     * syntactically reasonable, the derived table may be inlined to the query
     * that selects from the resulting table.
     */
    @NotNull
    @Support
    Table<R> where(Field<Boolean> field);

    Add a WHERE clause to the table.
 The resulting table acts like a derived table that projects all of this table's columns and filters by the argument Condition. If syntactically reasonable, the derived table may be inlined to the query that selects from the resulting table. 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.condition(SQL)
SQL/**
     * Add a <code>WHERE</code> clause to the table.
     * <p>
     * The resulting table acts like a derived table that projects all of this
     * table's columns and filters by the argument {@link Condition}. If
     * syntactically reasonable, the derived table may be inlined to the query
     * that selects from the resulting table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#condition(SQL)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<R> where(SQL sql);

    Add a WHERE clause to the table.
 The resulting table acts like a derived table that projects all of this table's columns and filters by the argument Condition. If syntactically reasonable, the derived table may be inlined to the query that selects from the resulting table. 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.condition(String)
SQL/**
     * Add a <code>WHERE</code> clause to the table.
     * <p>
     * The resulting table acts like a derived table that projects all of this
     * table's columns and filters by the argument {@link Condition}. If
     * syntactically reasonable, the derived table may be inlined to the query
     * that selects from the resulting table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#condition(String)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<R> where(String sql);

    Add a WHERE clause to the table.
 The resulting table acts like a derived table that projects all of this table's columns and filters by the argument Condition. If syntactically reasonable, the derived table may be inlined to the query that selects from the resulting table. 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.condition(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * Add a <code>WHERE</code> clause to the table.
     * <p>
     * The resulting table acts like a derived table that projects all of this
     * table's columns and filters by the argument {@link Condition}. If
     * syntactically reasonable, the derived table may be inlined to the query
     * that selects from the resulting table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#condition(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<R> where(String sql, Object... bindings);

    Add a WHERE clause to the table.
 The resulting table acts like a derived table that projects all of this table's columns and filters by the argument Condition. If syntactically reasonable, the derived table may be inlined to the query that selects from the resulting table. 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.condition(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * Add a <code>WHERE</code> clause to the table.
     * <p>
     * The resulting table acts like a derived table that projects all of this
     * table's columns and filters by the argument {@link Condition}. If
     * syntactically reasonable, the derived table may be inlined to the query
     * that selects from the resulting table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#condition(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<R> where(String sql, QueryPart... parts);

    Add a WHERE EXISTS clause to the table.
 The resulting table acts like a derived table that projects all of this table's columns and filters by the argument Condition. If syntactically reasonable, the derived table may be inlined to the query that selects from the resulting table. /**
     * Add a <code>WHERE EXISTS</code> clause to the table.
     * <p>
     * The resulting table acts like a derived table that projects all of this
     * table's columns and filters by the argument {@link Condition}. If
     * syntactically reasonable, the derived table may be inlined to the query
     * that selects from the resulting table.
     */
    @NotNull
    @Support
    Table<R> whereExists(Select<?> select);

    Add a WHERE NOT EXISTS clause to the table.
 The resulting table acts like a derived table that projects all of this table's columns and filters by the argument Condition. If syntactically reasonable, the derived table may be inlined to the query that selects from the resulting table. /**
     * Add a <code>WHERE NOT EXISTS</code> clause to the table.
     * <p>
     * The resulting table acts like a derived table that projects all of this
     * table's columns and filters by the argument {@link Condition}. If
     * syntactically reasonable, the derived table may be inlined to the query
     * that selects from the resulting table.
     */
    @NotNull
    @Support
    Table<R> whereNotExists(Select<?> select);

    // -------------------------------------------------------------------------
    // XXX: JOIN clauses on tables
    // -------------------------------------------------------------------------

    Join a table to this table using a JoinType 
Depending on the JoinType, a subsequent TableOnStep.on(Condition) or TableOnStep.using(Field...) clause is required. If it is required but omitted, a DSL.trueCondition(), i.e. 1 = 1
condition will be rendered
/**
     * Join a table to this table using a {@link JoinType}
     * <p>
     * Depending on the <code>JoinType</code>, a subsequent
     * {@link TableOnStep#on(Condition)} or
     * {@link TableOnStep#using(Field...)} clause is required. If it is required
     * but omitted, a {@link DSL#trueCondition()}, i.e. <code>1 = 1</code>
     * condition will be rendered
     */
    @NotNull
    @Support
    TableOptionalOnStep<Record> join(TableLike<?> table, JoinType type);

    INNER JOIN a table to this table.
 A synonym for innerJoin(TableLike). 
See Also: innerJoin(TableLike)/**
     * <code>INNER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #innerJoin(TableLike)}.
     *
     * @see #innerJoin(TableLike)
     */
    @NotNull
    @Support
    TableOnStep<Record> join(TableLike<?> table);

    INNER JOIN a table to this table.
 A synonym for innerJoin(String). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(SQL)
innerJoin(SQL)
SQL/**
     * <code>INNER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #innerJoin(String)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see #innerJoin(SQL)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TableOnStep<Record> join(SQL sql);

    INNER JOIN a table to this table.
 A synonym for innerJoin(String). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(String)
innerJoin(String)
SQL/**
     * <code>INNER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #innerJoin(String)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see #innerJoin(String)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TableOnStep<Record> join(String sql);

    INNER JOIN a table to this table.
 A synonym for innerJoin(String, Object...). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(String, Object...)
DSL.sql(String, Object...)
innerJoin(String, Object...)
SQL/**
     * <code>INNER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #innerJoin(String, Object...)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see #innerJoin(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TableOnStep<Record> join(String sql, Object... bindings);

    INNER JOIN a table to this table.
 A synonym for innerJoin(String, QueryPart...). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
innerJoin(String, QueryPart...)
SQL/**
     * <code>INNER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #innerJoin(String, QueryPart...)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see #innerJoin(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TableOnStep<Record> join(String sql, QueryPart... parts);

    INNER JOIN a table to this table.
 A synonym for innerJoin(Name). 
See Also: DSL.table(Name)
innerJoin(Name)/**
     * <code>INNER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #innerJoin(Name)}.
     *
     * @see DSL#table(Name)
     * @see #innerJoin(Name)
     */
    @NotNull
    @Support
    @PlainSQL
    TableOnStep<Record> join(Name name);

    INNER JOIN a table to this table.
/**
     * <code>INNER JOIN</code> a table to this table.
     */
    @NotNull
    @Support
    TableOnStep<Record> innerJoin(TableLike<?> table);

    INNER JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>INNER JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TableOnStep<Record> innerJoin(SQL sql);

    INNER JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>INNER JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TableOnStep<Record> innerJoin(String sql);

    INNER JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>INNER JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TableOnStep<Record> innerJoin(String sql, Object... bindings);

    INNER JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>INNER JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TableOnStep<Record> innerJoin(String sql, QueryPart... parts);

    INNER JOIN a table to this table.
See Also: table.table(Name)/**
     * <code>INNER JOIN</code> a table to this table.
     *
     * @see DSL#table(Name)
     */
    @NotNull
    @Support
    TableOnStep<Record> innerJoin(Name name);





















    LEFT OUTER JOIN a table to this table.
 A synonym for leftOuterJoin(TableLike). 
See Also: leftOuterJoin(TableLike)/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #leftOuterJoin(TableLike)}.
     *
     * @see #leftOuterJoin(TableLike)
     */
    @NotNull
    @Support
    TablePartitionByStep<Record> leftJoin(TableLike<?> table);

    LEFT OUTER JOIN a table to this table.
 A synonym for leftOuterJoin(String). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(SQL)
leftOuterJoin(SQL)
SQL/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #leftOuterJoin(String)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see #leftOuterJoin(SQL)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TablePartitionByStep<Record> leftJoin(SQL sql);

    LEFT OUTER JOIN a table to this table.
 A synonym for leftOuterJoin(String). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(String)
leftOuterJoin(String)
SQL/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #leftOuterJoin(String)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see #leftOuterJoin(String)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TablePartitionByStep<Record> leftJoin(String sql);

    LEFT OUTER JOIN a table to this table.
 A synonym for leftOuterJoin(String, Object...). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(String, Object...)
DSL.sql(String, Object...)
leftOuterJoin(String, Object...)
SQL/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #leftOuterJoin(String, Object...)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see #leftOuterJoin(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TablePartitionByStep<Record> leftJoin(String sql, Object... bindings);

    LEFT OUTER JOIN a table to this table.
 A synonym for leftOuterJoin(String, QueryPart...). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
leftOuterJoin(String, QueryPart...)
SQL/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #leftOuterJoin(String, QueryPart...)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see #leftOuterJoin(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TablePartitionByStep<Record> leftJoin(String sql, QueryPart... parts);

    LEFT OUTER JOIN a table to this table.
 A synonym for leftOuterJoin(Name). 
See Also: DSL.table(Name)
leftOuterJoin(Name)/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #leftOuterJoin(Name)}.
     *
     * @see DSL#table(Name)
     * @see #leftOuterJoin(Name)
     */
    @NotNull
    @Support
    TablePartitionByStep<Record> leftJoin(Name name);

    LEFT OUTER JOIN a table to this table.
/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     */
    @NotNull
    @Support
    TablePartitionByStep<Record> leftOuterJoin(TableLike<?> table);

    LEFT OUTER JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TablePartitionByStep<Record> leftOuterJoin(SQL sql);

    LEFT OUTER JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TablePartitionByStep<Record> leftOuterJoin(String sql);

    LEFT OUTER JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TablePartitionByStep<Record> leftOuterJoin(String sql, Object... bindings);

    LEFT OUTER JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    TablePartitionByStep<Record> leftOuterJoin(String sql, QueryPart... parts);

    LEFT OUTER JOIN a table to this table.
See Also: table.table(Name)
SQL/**
     * <code>LEFT OUTER JOIN</code> a table to this table.
     *
     * @see DSL#table(Name)
     * @see SQL
     */
    @NotNull
    @Support
    TablePartitionByStep<Record> leftOuterJoin(Name name);

    RIGHT OUTER JOIN a table to this table.
 A synonym for rightOuterJoin(TableLike). 

This is only possible where the underlying RDBMS supports it.
See Also: rightOuterJoin(TableLike)/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #rightOuterJoin(TableLike)}.
     * <p>
     * This is only possible where the underlying RDBMS supports it.
     *
     * @see #rightOuterJoin(TableLike)
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    TablePartitionByStep<Record> rightJoin(TableLike<?> table);

    RIGHT OUTER JOIN a table to this table.
 A synonym for 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. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(SQL)
rightOuterJoin(SQL)
SQL/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #rightOuterJoin(String)}.
     * <p>
     * This is only possible where the underlying RDBMS supports it.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see #rightOuterJoin(SQL)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    TablePartitionByStep<Record> rightJoin(SQL sql);

    RIGHT OUTER JOIN a table to this table.
 A synonym for 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. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(String)
rightOuterJoin(String)
SQL/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #rightOuterJoin(String)}.
     * <p>
     * This is only possible where the underlying RDBMS supports it.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see #rightOuterJoin(String)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    TablePartitionByStep<Record> rightJoin(String sql);

    RIGHT OUTER JOIN a table to this table.
 A synonym for rightOuterJoin(String, Object...). 

This is only possible where the underlying RDBMS supports it.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(String, Object...)
DSL.sql(String, Object...)
rightOuterJoin(String, Object...)
SQL/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #rightOuterJoin(String, Object...)}.
     * <p>
     * This is only possible where the underlying RDBMS supports it.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see #rightOuterJoin(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    TablePartitionByStep<Record> rightJoin(String sql, Object... bindings);

    RIGHT OUTER JOIN a table to this table.
 A synonym for rightOuterJoin(String, QueryPart...). 

This is only possible where the underlying RDBMS supports it

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: DSL.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
rightOuterJoin(String, QueryPart...)
SQL/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #rightOuterJoin(String, QueryPart...)}.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see #rightOuterJoin(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    TablePartitionByStep<Record> rightJoin(String sql, QueryPart... parts);

    RIGHT OUTER JOIN a table to this table.
 A synonym for rightOuterJoin(Name). 

This is only possible where the underlying RDBMS supports it
See Also: DSL.table(Name)
rightOuterJoin(Name)/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #rightOuterJoin(Name)}.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     *
     * @see DSL#table(Name)
     * @see #rightOuterJoin(Name)
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    TablePartitionByStep<Record> rightJoin(Name name);

    RIGHT OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it
/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    TablePartitionByStep<Record> rightOuterJoin(TableLike<?> table);

    RIGHT OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    TablePartitionByStep<Record> rightOuterJoin(SQL sql);

    RIGHT OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    TablePartitionByStep<Record> rightOuterJoin(String sql);

    RIGHT OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    TablePartitionByStep<Record> rightOuterJoin(String sql, Object... bindings);

    RIGHT OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    TablePartitionByStep<Record> rightOuterJoin(String sql, QueryPart... parts);

    RIGHT OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it
See Also: table.table(Name)/**
     * <code>RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     *
     * @see DSL#table(Name)
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    TablePartitionByStep<Record> rightOuterJoin(Name name);

    FULL OUTER JOIN a table to this table.
 A synonym for fullOuterJoin(TableLike). /**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #fullOuterJoin(TableLike)}.
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    TableOnStep<Record> fullJoin(TableLike<?> table);

    FULL OUTER JOIN a table to this table.
 A synonym for fullOuterJoin(SQL). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
/**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #fullOuterJoin(SQL)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    TableOnStep<Record> fullJoin(SQL sql);

    FULL OUTER JOIN a table to this table.
 A synonym for fullOuterJoin(String). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
/**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #fullOuterJoin(String)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    TableOnStep<Record> fullJoin(String sql);

    FULL OUTER JOIN a table to this table.
 A synonym for fullOuterJoin(String, Object...). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
/**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #fullOuterJoin(String, Object...)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    TableOnStep<Record> fullJoin(String sql, Object... bindings);

    FULL OUTER JOIN a table to this table.
 A synonym for fullOuterJoin(String, QueryPart...). 

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
/**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #fullOuterJoin(String, QueryPart...)}.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    TableOnStep<Record> fullJoin(String sql, QueryPart... parts);

    FULL OUTER JOIN a table to this table.
 A synonym for fullOuterJoin(Name). /**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * A synonym for {@link #fullOuterJoin(Name)}.
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    TableOnStep<Record> fullJoin(Name name);

    FULL OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it
/**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    TableOnStep<Record> fullOuterJoin(TableLike<?> table);

    FULL OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    TableOnStep<Record> fullOuterJoin(SQL sql);

    FULL OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    TableOnStep<Record> fullOuterJoin(String sql);

    FULL OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    TableOnStep<Record> fullOuterJoin(String sql, Object... bindings);

    FULL OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    TableOnStep<Record> fullOuterJoin(String sql, QueryPart... parts);

    FULL OUTER JOIN a table to this table.

This is only possible where the underlying RDBMS supports it
See Also: table.table(Name)/**
     * <code>FULL OUTER JOIN</code> a table to this table.
     * <p>
     * This is only possible where the underlying RDBMS supports it
     *
     * @see DSL#table(Name)
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    TableOnStep<Record> fullOuterJoin(Name name);

    CROSS JOIN a table to this table.

If this syntax is unavailable, it is emulated with a regular
INNER JOIN. The following two constructs are equivalent:
A cross join B
A join B on 1 = 1

/**
     * <code>CROSS JOIN</code> a table to this table.
     * <p>
     * If this syntax is unavailable, it is emulated with a regular
     * <code>INNER JOIN</code>. The following two constructs are equivalent:
     * <code><pre>
     * A cross join B
     * A join B on 1 = 1
     * </pre></code>
     */
    @NotNull
    @Support
    Table<Record> crossJoin(TableLike<?> table);

    CROSS JOIN a table to this table.

If this syntax is unavailable, it is emulated with a regular
INNER JOIN. The following two constructs are equivalent:
A cross join B
A join B on 1 = 1


NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>CROSS JOIN</code> a table to this table.
     * <p>
     * If this syntax is unavailable, it is emulated with a regular
     * <code>INNER JOIN</code>. The following two constructs are equivalent:
     * <code><pre>
     * A cross join B
     * A join B on 1 = 1
     * </pre></code>
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> crossJoin(SQL sql);

    CROSS JOIN a table to this table.

If this syntax is unavailable, it is emulated with a regular
INNER JOIN. The following two constructs are equivalent:
A cross join B
A join B on 1 = 1


NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>CROSS JOIN</code> a table to this table.
     * <p>
     * If this syntax is unavailable, it is emulated with a regular
     * <code>INNER JOIN</code>. The following two constructs are equivalent:
     * <code><pre>
     * A cross join B
     * A join B on 1 = 1
     * </pre></code>
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> crossJoin(String sql);

    CROSS JOIN a table to this table.

If this syntax is unavailable, it is emulated with a regular
INNER JOIN. The following two constructs are equivalent:
A cross join B
A join B on 1 = 1


NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>CROSS JOIN</code> a table to this table.
     * <p>
     * If this syntax is unavailable, it is emulated with a regular
     * <code>INNER JOIN</code>. The following two constructs are equivalent:
     * <code><pre>
     * A cross join B
     * A join B on 1 = 1
     * </pre></code>
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> crossJoin(String sql, Object... bindings);

    CROSS JOIN a table to this table.

If this syntax is unavailable, it is emulated with a regular
INNER JOIN. The following two constructs are equivalent:
A cross join B
A join B on 1 = 1


NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>CROSS JOIN</code> a table to this table.
     * <p>
     * If this syntax is unavailable, it is emulated with a regular
     * <code>INNER JOIN</code>. The following two constructs are equivalent:
     * <code><pre>
     * A cross join B
     * A join B on 1 = 1
     * </pre></code>
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> crossJoin(String sql, QueryPart... parts);

    CROSS JOIN a table to this table.

If this syntax is unavailable, it is emulated with a regular
INNER JOIN. The following two constructs are equivalent:
A cross join B
A join B on 1 = 1

See Also: table.table(Name)/**
     * <code>CROSS JOIN</code> a table to this table.
     * <p>
     * If this syntax is unavailable, it is emulated with a regular
     * <code>INNER JOIN</code>. The following two constructs are equivalent:
     * <code><pre>
     * A cross join B
     * A join B on 1 = 1
     * </pre></code>
     *
     * @see DSL#table(Name)
     */
    @NotNull
    @Support
    Table<Record> crossJoin(Name name);

    NATURAL JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.
/**
     * <code>NATURAL JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     */
    @NotNull
    @Support
    Table<Record> naturalJoin(TableLike<?> table);

    NATURAL JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>NATURAL JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> naturalJoin(SQL sql);

    NATURAL JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>NATURAL JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> naturalJoin(String sql);

    NATURAL JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>NATURAL JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> naturalJoin(String sql, Object... bindings);

    NATURAL JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.
See Also: table.table(Name)/**
     * <code>NATURAL JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     *
     * @see DSL#table(Name)
     */
    @NotNull
    @Support
    Table<Record> naturalJoin(Name name);

    NATURAL JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>NATURAL JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> naturalJoin(String sql, QueryPart... parts);

    NATURAL LEFT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.
/**
     * <code>NATURAL LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     */
    @NotNull
    @Support
    Table<Record> naturalLeftOuterJoin(TableLike<?> table);

    NATURAL LEFT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>NATURAL LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> naturalLeftOuterJoin(SQL sql);

    NATURAL LEFT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>NATURAL LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> naturalLeftOuterJoin(String sql);

    NATURAL LEFT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>NATURAL LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> naturalLeftOuterJoin(String sql, Object... bindings);

    NATURAL LEFT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>NATURAL LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> naturalLeftOuterJoin(String sql, QueryPart... parts);

    NATURAL LEFT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.
See Also: table.table(Name)/**
     * <code>NATURAL LEFT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     *
     * @see DSL#table(Name)
     */
    @NotNull
    @Support
    @PlainSQL
    Table<Record> naturalLeftOuterJoin(Name name);

    NATURAL RIGHT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.
/**
     * <code>NATURAL RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    Table<Record> naturalRightOuterJoin(TableLike<?> table);

    NATURAL RIGHT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>NATURAL RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    Table<Record> naturalRightOuterJoin(SQL sql);

    NATURAL RIGHT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>NATURAL RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    Table<Record> naturalRightOuterJoin(String sql);

    NATURAL RIGHT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>NATURAL RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    Table<Record> naturalRightOuterJoin(String sql, Object... bindings);

    NATURAL RIGHT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>NATURAL RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    @PlainSQL
    Table<Record> naturalRightOuterJoin(String sql, QueryPart... parts);

    NATURAL RIGHT OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.
See Also: table.table(Name)/**
     * <code>NATURAL RIGHT OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     *
     * @see DSL#table(Name)
     */
    @NotNull
    @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
    Table<Record> naturalRightOuterJoin(Name name);

    NATURAL FULL OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.
/**
     * <code>NATURAL FULL OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    Table<Record> naturalFullOuterJoin(TableLike<?> table);

    NATURAL FULL OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>NATURAL FULL OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    Table<Record> naturalFullOuterJoin(SQL sql);

    NATURAL FULL OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>NATURAL FULL OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    Table<Record> naturalFullOuterJoin(String sql);

    NATURAL FULL OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>NATURAL FULL OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    Table<Record> naturalFullOuterJoin(String sql, Object... bindings);

    NATURAL FULL OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>NATURAL FULL OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    @PlainSQL
    Table<Record> naturalFullOuterJoin(String sql, QueryPart... parts);

    NATURAL FULL OUTER JOIN a table to this table.

If this is not supported by your RDBMS, then jOOQ will try to emulate
this behaviour using the information provided in this query.
See Also: table.table(Name)/**
     * <code>NATURAL FULL OUTER JOIN</code> a table to this table.
     * <p>
     * If this is not supported by your RDBMS, then jOOQ will try to emulate
     * this behaviour using the information provided in this query.
     *
     * @see DSL#table(Name)
     */
    @NotNull
    @Support({ FIREBIRD, HSQLDB, POSTGRES })
    Table<Record> naturalFullOuterJoin(Name name);

    // -------------------------------------------------------------------------
    // XXX: APPLY clauses on tables
    // -------------------------------------------------------------------------

    CROSS APPLY a table to this table.
/**
     * <code>CROSS APPLY</code> a table to this table.
     */
    @NotNull
    @Support({ POSTGRES })
    Table<Record> crossApply(TableLike<?> table);

    CROSS APPLY a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>CROSS APPLY</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support({ POSTGRES })
    @PlainSQL
    Table<Record> crossApply(SQL sql);

    CROSS APPLY a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>CROSS APPLY</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support({ POSTGRES })
    @PlainSQL
    Table<Record> crossApply(String sql);

    CROSS APPLY a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>CROSS APPLY</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support({ POSTGRES })
    @PlainSQL
    Table<Record> crossApply(String sql, Object... bindings);

    CROSS APPLY a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>CROSS APPLY</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support({ POSTGRES })
    @PlainSQL
    Table<Record> crossApply(String sql, QueryPart... parts);

    CROSS APPLY a table to this table.
See Also: table.table(Name)/**
     * <code>CROSS APPLY</code> a table to this table.
     *
     * @see DSL#table(Name)
     */
    @NotNull
    @Support({ POSTGRES })
    Table<Record> crossApply(Name name);

    OUTER APPLY a table to this table.
/**
     * <code>OUTER APPLY</code> a table to this table.
     */
    @NotNull
    @Support({ POSTGRES })
    Table<Record> outerApply(TableLike<?> table);

    OUTER APPLY a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>OUTER APPLY</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support({ POSTGRES })
    @PlainSQL
    Table<Record> outerApply(SQL sql);

    OUTER APPLY a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>OUTER APPLY</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support({ POSTGRES })
    @PlainSQL
    Table<Record> outerApply(String sql);

    OUTER APPLY a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>OUTER APPLY</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support({ POSTGRES })
    @PlainSQL
    Table<Record> outerApply(String sql, Object... bindings);

    OUTER APPLY a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>OUTER APPLY</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support({ POSTGRES })
    @PlainSQL
    Table<Record> outerApply(String sql, QueryPart... parts);

    OUTER APPLY a table to this table.
See Also: table.table(Name)/**
     * <code>OUTER APPLY</code> a table to this table.
     *
     * @see DSL#table(Name)
     */
    @NotNull
    @Support({ POSTGRES })
    Table<Record> outerApply(Name name);

    STRAIGHT_JOIN a table to this table.
/**
     * <code>STRAIGHT_JOIN</code> a table to this table.
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    TableOnStep<Record> straightJoin(TableLike<?> table);

    STRAIGHT_JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(SQL)
SQL/**
     * <code>STRAIGHT_JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(SQL)
     * @see SQL
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    @PlainSQL
    TableOnStep<Record> straightJoin(SQL sql);

    STRAIGHT_JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String)
SQL/**
     * <code>STRAIGHT_JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String)
     * @see SQL
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    @PlainSQL
    TableOnStep<Record> straightJoin(String sql);

    STRAIGHT_JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, Object...)
DSL.sql(String, Object...)
SQL/**
     * <code>STRAIGHT_JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, Object...)
     * @see DSL#sql(String, Object...)
     * @see SQL
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    @PlainSQL
    TableOnStep<Record> straightJoin(String sql, Object... bindings);

    STRAIGHT_JOIN a table to this table.

NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. You may also create the possibility of
malicious SQL injection. Be sure to properly use bind variables and/or
escape literals when concatenated into SQL clauses!
See Also: table.table(String, QueryPart...)
DSL.sql(String, QueryPart...)
SQL/**
     * <code>STRAIGHT_JOIN</code> a table to this table.
     * <p>
     * <b>NOTE</b>: When inserting plain SQL into jOOQ objects, you must
     * guarantee syntax integrity. You may also create the possibility of
     * malicious SQL injection. Be sure to properly use bind variables and/or
     * escape literals when concatenated into SQL clauses!
     *
     * @see DSL#table(String, QueryPart...)
     * @see DSL#sql(String, QueryPart...)
     * @see SQL
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    @PlainSQL
    TableOnStep<Record> straightJoin(String sql, QueryPart... parts);

    STRAIGHT_JOIN a table to this table.
See Also: table.table(Name)/**
     * <code>STRAIGHT_JOIN</code> a table to this table.
     *
     * @see DSL#table(Name)
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    @PlainSQL
    TableOnStep<Record> straightJoin(Name name);

    // -------------------------------------------------------------------------
    // XXX: Convenience methods and synthetic methods
    // -------------------------------------------------------------------------

    Create a predicate comparing records from self-joined tables.

This is a convenience method for self-joins, comparing complete records
between tables.

For example: 
MyTable a = MY_TABLE.as("a");
MyTable b = MY_TABLE.as("b");
DSL.using(configuration)
   .select()
   .from(a)
   .join(b).on(a.eq(b));

See Also: equal(Table)/**
     * Create a predicate comparing records from self-joined tables.
     * <p>
     * This is a convenience method for self-joins, comparing complete records
     * between tables.
     * <p>
     * For example: <code><pre>
     * MyTable a = MY_TABLE.as("a");
     * MyTable b = MY_TABLE.as("b");
     *
     * DSL.using(configuration)
     *    .select()
     *    .from(a)
     *    .join(b).on(a.eq(b));
     * </pre></code>
     *
     * @see #equal(Table)
     */
    @NotNull
    @Support
    Condition eq(Table<R> table);

    Create a predicate comparing records from self-joined tables.

This is a convenience method for self-joins, comparing complete records
between tables.

For example:
MyTable a = MY_TABLE.as("a");
MyTable b = MY_TABLE.as("b");
DSL.using(configuration)
   .select()
   .from(a)
   .join(b).on(a.equal(b));

/**
     * Create a predicate comparing records from self-joined tables.
     * <p>
     * This is a convenience method for self-joins, comparing complete records
     * between tables.
     * <p>
     * For example:
     * <code><pre>
     * MyTable a = MY_TABLE.as("a");
     * MyTable b = MY_TABLE.as("b");
     *
     * DSL.using(configuration)
     *    .select()
     *    .from(a)
     *    .join(b).on(a.equal(b));
     * </pre></code>
     */
    @NotNull
    @Support
    Condition equal(Table<R> table);

    {@inheritDoc}

Watch out! This is Object.equals(Object), not a jOOQ DSL feature!
/**
     * {@inheritDoc}
     * <p>
     * <strong>Watch out! This is {@link Object#equals(Object)}, not a jOOQ DSL
     * feature!</strong>
     */
    @Override
    boolean equals(Object other);

    Create a predicate comparing records from self-non-equi-joined tables.
This is a convenience method for self-joins, comparing complete records
between tables.

For example:
MyTable a = MY_TABLE.as("a");
MyTable b = MY_TABLE.as("b");
DSL.using(configuration)
   .select()
   .from(a)
   .join(b).on(a.ne(b));

See Also: notEqual(Table)/**
     * Create a predicate comparing records from self-non-equi-joined tables.
     * This is a convenience method for self-joins, comparing complete records
     * between tables.
     * <p>
     * For example:
     * <code><pre>
     * MyTable a = MY_TABLE.as("a");
     * MyTable b = MY_TABLE.as("b");
     *
     * DSL.using(configuration)
     *    .select()
     *    .from(a)
     *    .join(b).on(a.ne(b));
     * </pre></code>
     *
     * @see #notEqual(Table)
     */
    @NotNull
    @Support
    Condition ne(Table<R> table);

    Create a predicate comparing records from self-non-equi-joined tables.

This is a convenience method for self-joins, comparing complete records
between tables.

For example:
MyTable a = MY_TABLE.as("a");
MyTable b = MY_TABLE.as("b");
DSL.using(configuration)
   .select()
   .from(a)
   .join(b).on(a.notEqual(b));

/**
     * Create a predicate comparing records from self-non-equi-joined tables.
     * <p>
     * This is a convenience method for self-joins, comparing complete records
     * between tables.
     * <p>
     * For example:
     * <code><pre>
     * MyTable a = MY_TABLE.as("a");
     * MyTable b = MY_TABLE.as("b");
     *
     * DSL.using(configuration)
     *    .select()
     *    .from(a)
     *    .join(b).on(a.notEqual(b));
     * </pre></code>
     */
    @NotNull
    @Support
    Condition notEqual(Table<R> table);

    // -------------------------------------------------------------------------
    // XXX: Exotic and vendor-specific clauses on tables
    // -------------------------------------------------------------------------

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndex("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndex("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> useIndex(String... indexes);

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndexForJoin("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndexForJoin("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> useIndexForJoin(String... indexes);

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndexForOrderBy("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndexForOrderBy("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> useIndexForOrderBy(String... indexes);

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndexForGroupBy("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndexForGroupBy("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> useIndexForGroupBy(String... indexes);

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndex("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndex("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> ignoreIndex(String... indexes);

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndexForJoin("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndexForJoin("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> ignoreIndexForJoin(String... indexes);

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndexForOrderBy("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndexForOrderBy("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> ignoreIndexForOrderBy(String... indexes);

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndexForGroupBy("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndexForGroupBy("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> ignoreIndexForGroupBy(String... indexes);

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndex("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndex("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> forceIndex(String... indexes);

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndexForJoin("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndexForJoin("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> forceIndexForJoin(String... indexes);

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndexForOrderBy("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndexForOrderBy("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> forceIndexForOrderBy(String... indexes);

    Specify a MySQL style table hint for query optimisation.

Example:

create.select()
      .from(BOOK.as("b").useIndexForGroupBy("MY_INDEX")
      .fetch();

See Also: http://dev.mysql.com/doc/refman/5.7/en/index-hints.html/**
     * Specify a MySQL style table hint for query optimisation.
     * <p>
     * Example:
     * <p>
     * <code><pre>
     * create.select()
     *       .from(BOOK.as("b").useIndexForGroupBy("MY_INDEX")
     *       .fetch();
     * </pre></code>
     *
     * @see <a
     *      href="http://dev.mysql.com/doc/refman/5.7/en/index-hints.html">http://dev.mysql.com/doc/refman/5.7/en/index-hints.html</a>
     */
    @NotNull
    @Support({ MARIADB, MYSQL })
    Table<R> forceIndexForGroupBy(String... indexes);











































































































































































    Create a new TABLE reference from this table, applying
relational division.

Relational division is the inverse of a cross join operation. The
following is an approximate definition of a relational division:
Assume the following cross join / cartesian product
C = A × B
Then it can be said that
A = C ÷ B
B = C ÷ A


With jOOQ, you can simplify using relational divisions by using the
following syntax: 
C.divideBy(B).on(C.ID.equal(B.C_ID)).returning(C.TEXT)


The above roughly translates to 
SELECT DISTINCT C.TEXT FROM C "c1"
WHERE NOT EXISTS (
  SELECT 1 FROM B
  WHERE NOT EXISTS (
    SELECT 1 FROM C "c2"
    WHERE "c2".TEXT = "c1".TEXT
    AND "c2".ID = B.C_ID
  )
)


Or in plain text: Find those TEXT values in C whose ID's correspond to
all ID's in B. Note that from the above SQL statement, it is immediately
clear that proper indexing is of the essence. Be sure to have indexes on
all columns referenced from the on(...) and
returning(...) clauses.

For more information about relational division and some nice, real-life
examples, see

http
://en.wikipedia.org/wiki/Relational_algebra#Division
http://www.simple-talk.com/sql/t-sql-programming/divided-we-stand-the-
sql-of-relational-division/


This has been observed to work with all dialects
/**
     * Create a new <code>TABLE</code> reference from this table, applying
     * relational division.
     * <p>
     * Relational division is the inverse of a cross join operation. The
     * following is an approximate definition of a relational division:
     * <code><pre>
     * Assume the following cross join / cartesian product
     * C = A × B
     *
     * Then it can be said that
     * A = C ÷ B
     * B = C ÷ A
     * </pre></code>
     * <p>
     * With jOOQ, you can simplify using relational divisions by using the
     * following syntax: <code><pre>
     * C.divideBy(B).on(C.ID.equal(B.C_ID)).returning(C.TEXT)
     * </pre></code>
     * <p>
     * The above roughly translates to <code><pre>
     * SELECT DISTINCT C.TEXT FROM C "c1"
     * WHERE NOT EXISTS (
     *   SELECT 1 FROM B
     *   WHERE NOT EXISTS (
     *     SELECT 1 FROM C "c2"
     *     WHERE "c2".TEXT = "c1".TEXT
     *     AND "c2".ID = B.C_ID
     *   )
     * )
     * </pre></code>
     * <p>
     * Or in plain text: Find those TEXT values in C whose ID's correspond to
     * all ID's in B. Note that from the above SQL statement, it is immediately
     * clear that proper indexing is of the essence. Be sure to have indexes on
     * all columns referenced from the <code>on(...)</code> and
     * <code>returning(...)</code> clauses.
     * <p>
     * For more information about relational division and some nice, real-life
     * examples, see
     * <ul>
     * <li><a
     * href="http://en.wikipedia.org/wiki/Relational_algebra#Division">http
     * ://en.wikipedia.org/wiki/Relational_algebra#Division</a></li>
     * <li><a href=
     * "http://www.simple-talk.com/sql/t-sql-programming/divided-we-stand-the-sql-of-relational-division/"
     * >http://www.simple-talk.com/sql/t-sql-programming/divided-we-stand-the-
     * sql-of-relational-division/</a></li>
     * </ul>
     * <p>
     * This has been observed to work with all dialects
     */
    @NotNull
    @Support
    DivideByOnStep divideBy(Table<?> divisor);

    A synthetic LEFT SEMI JOIN clause that translates to an
equivalent EXISTS predicate.

The following two SQL snippets are semantically equivalent:
-- Using LEFT SEMI JOIN
FROM A
    LEFT SEMI JOIN B
        ON A.ID = B.ID
-- Using WHERE EXISTS
FROM A
WHERE EXISTS (
    SELECT 1 FROM B WHERE A.ID = B.ID
)


Notice that according to
Relational
algebra's understanding of left semi join, the right hand side of the
left semi join operator is not projected, i.e. it cannot be accessed from
WHERE or SELECT or any other clause than
ON.
/**
     * A synthetic <code>LEFT SEMI JOIN</code> clause that translates to an
     * equivalent <code>EXISTS</code> predicate.
     * <p>
     * The following two SQL snippets are semantically equivalent:
     * <code><pre>
     * -- Using LEFT SEMI JOIN
     * FROM A
     *     LEFT SEMI JOIN B
     *         ON A.ID = B.ID
     *
     * -- Using WHERE EXISTS
     * FROM A
     * WHERE EXISTS (
     *     SELECT 1 FROM B WHERE A.ID = B.ID
     * )
     * </pre></code>
     * <p>
     * Notice that according to
     * <a href="https://en.wikipedia.org/wiki/Relational_algebra">Relational
     * algebra's</a> understanding of left semi join, the right hand side of the
     * left semi join operator is not projected, i.e. it cannot be accessed from
     * <code>WHERE</code> or <code>SELECT</code> or any other clause than
     * <code>ON</code>.
     */
    @NotNull
    @Support
    TableOnStep<R> leftSemiJoin(TableLike<?> table);

    A synthetic LEFT ANTI JOIN clause that translates to an
equivalent NOT EXISTS predicate.

The following two SQL snippets are semantically equivalent:
-- Using LEFT ANTI JOIN
FROM A
    LEFT ANTI JOIN B
        ON A.ID = B.ID
-- Using WHERE NOT EXISTS
FROM A
WHERE NOT EXISTS (
    SELECT 1 FROM B WHERE A.ID = B.ID
)


Notice that according to
Relational
algebra's understanding of left anti join, the right hand side of the
left anti join operator is not projected, i.e. it cannot be accessed from
WHERE or SELECT or any other clause than
ON.
/**
     * A synthetic <code>LEFT ANTI JOIN</code> clause that translates to an
     * equivalent <code>NOT EXISTS</code> predicate.
     * <p>
     * The following two SQL snippets are semantically equivalent:
     * <code><pre>
     * -- Using LEFT ANTI JOIN
     * FROM A
     *     LEFT ANTI JOIN B
     *         ON A.ID = B.ID
     *
     * -- Using WHERE NOT EXISTS
     * FROM A
     * WHERE NOT EXISTS (
     *     SELECT 1 FROM B WHERE A.ID = B.ID
     * )
     * </pre></code>
     * <p>
     * Notice that according to
     * <a href="https://en.wikipedia.org/wiki/Relational_algebra">Relational
     * algebra's</a> understanding of left anti join, the right hand side of the
     * left anti join operator is not projected, i.e. it cannot be accessed from
     * <code>WHERE</code> or <code>SELECT</code> or any other clause than
     * <code>ON</code>.
     */
    @NotNull
    @Support
    TableOnStep<R> leftAntiJoin(TableLike<?> table);




















































































































    // ------------------------------------------------------------------------
    // [#5518] Record method inversions, e.g. for use as method references
    // ------------------------------------------------------------------------

    The inverse operation of Record.into(Table<Record>). 
This method can be used in its method reference form conveniently on a
generated table, for instance, when mapping records in a stream:
DSL.using(configuration)
   .fetch("select * from t")
   .stream()
   .map(MY_TABLE::into)
   .forEach(System.out::println);

/**
     * The inverse operation of {@link Record#into(Table)}.
     * <p>
     * This method can be used in its method reference form conveniently on a
     * generated table, for instance, when mapping records in a stream:
     * <code><pre>
     * DSL.using(configuration)
     *    .fetch("select * from t")
     *    .stream()
     *    .map(MY_TABLE::into)
     *    .forEach(System.out::println);
     * </pre></code>
     */
    @NotNull
    R from(Record record);
}
Author:	Lukas Eder
Type parameters:	<R> – The record type associated with this table
See Also:	getRecordTimestamp() UpdatableRecord.store() UpdatableRecord.delete() Settings.isExecuteWithOptimisticLocking()
Returns:	The "version" field, or `null`, if this table has no "version" field.
See Also:	getRecordVersion() UpdatableRecord.store() UpdatableRecord.delete() Settings.isExecuteWithOptimisticLocking()
Returns:	The "timestamp" field, or `null`, if this table has no "timestamp" field.
Params:	other – The other table of the foreign key relationship
Type parameters:	<O> – The other table's record type
Returns:	Some other table's `FOREIGN KEY`'s towards an this table. This is never `null`. This method returns an unmodifiable list.
Params:	alias – The alias name fieldAliases – The field aliases. Excess aliases are ignored, missing aliases will be substituted by this table's field names.
Returns:	The table alias
Params:	alias – The alias name aliasFunction – The function providing field aliases.
Returns:	The table alias
Deprecated:	- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.
Params:	otherTable – The other table whose name this table is aliased with.
Returns:	The table alias.
/

org.jooq/ jooq/ 3.14.7/ org/jooq/Table.java

Derived column lists for table references

Derived column lists for derived tables

Derived column lists for table references

Derived column lists for derived tables
