org.jooq.Table Maven / Gradle / Ivy
/*
* 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
*
* https://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: https://www.jooq.org/legal/licensing
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
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.IGNITE;
// ...
// ...
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 static org.jooq.SQLDialect.YUGABYTEDB;
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 {@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:
*
*
* - Generated table or view references
* - Plain SQL tables created with {@link DSL#table(String)}
* - Table references created with {@link DSL#table(Name)}
* - Derived tables created with {@link DSL#table(Select)}
* - Join expressions created e.g. with {@link Table#join(TableLike)}
* - Common table expressions ({@link CommonTableExpression})
* - Unnested arrays referenced through {@link 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 {@link DSL#table(Name)} and overloads.
*
*
Using table references as field expressions
*
* Table references can be used like {@link Field} in queries. This includes:
*
* - A {@link GroupField} is an expression that is used in a {@link Select}
* query's
GROUP BY clause.
* - A {@link SelectField} is an expression that is used in a {@link Select}
* query's
SELECT clause, or in a DML query's
* RETURNING clause, such as INSERT … RETURNING.
*
*
* Other types of {@link Table} cannot be used this way, even if the type system
* cannot prevent this.
*
* @param The record type associated with this table
* @author Lukas Eder
*/
public non-sealed interface Table
extends
TableLike,
RecordQualifier,
GroupField,
SelectField
{
/**
* Get the table type.
*/
@NotNull
TableType getTableType();
/**
* Get the table options.
*/
@NotNull
TableOptions getOptions();
/**
* The record type produced by this table.
*/
@NotNull
RecordType recordType();
/**
* 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.
*
* @return The table's IDENTITY information, or
* null, if no such information is available.
*/
@Nullable
Identity getIdentity();
/**
* Retrieve the table's primary key
*
* @return The primary key. This is never null for an updatable
* table.
*/
@Nullable
UniqueKey getPrimaryKey();
/**
* A "version" field holding record version information used for optimistic
* locking
*
* 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 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.
*
* @return The "version" field, or null, if this table has no
* "version" field.
* @see #getRecordTimestamp()
* @see UpdatableRecord#store()
* @see UpdatableRecord#delete()
* @see Settings#isExecuteWithOptimisticLocking()
*/
@Nullable
TableField getRecordVersion();
/**
* A "timestamp" field holding record timestamp information used for
* optimistic locking
*
* 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 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.
*
* @return The "timestamp" field, or null, if this table has no
* "timestamp" field.
* @see #getRecordVersion()
* @see UpdatableRecord#store()
* @see UpdatableRecord#delete()
* @see Settings#isExecuteWithOptimisticLocking()
*/
@Nullable
TableField getRecordTimestamp();
/**
* Retrieve all of the table's indexes.
*
* @return All indexes. This is never null.
*/
@NotNull
List getIndexes();
/**
* Retrieve all of the table's primary and unique keys.
*
* @return All keys. This is never null. This is never empty
* for a {@link Table} with a {@link Table#getPrimaryKey()}.
*/
@NotNull
List> getKeys();
/**
* Retrieve all of the table's unique keys.
*
* @return All keys. This is never null.
*/
@NotNull
List> getUniqueKeys();
/**
* Get a list of FOREIGN KEY's of a specific table, referencing
* a this table.
*
* This will recurse into joined tables.
*
* @param The other table's record type
* @param other The other table of the foreign key relationship
* @return Some other table's FOREIGN KEY's towards an this
* table. This is never null.
*/
@NotNull
List> getReferencesFrom(Table other);
/**
* Get the list of FOREIGN KEY's of this table
*
* @return This table's FOREIGN KEY's. This is never
* null.
*/
@NotNull
List> getReferences();
/**
* Get a list of FOREIGN KEY's of this table, referencing a
* specific table.
*
* This will recurse into joined tables.
*
* @param The other table's record type
* @param other The other table of the foreign key relationship
* @return This table's FOREIGN KEY's towards an other table.
* This is never null.
*/
@NotNull
List> getReferencesTo(Table other);
/**
* Get a list of CHECK constraints of this table.
*/
@NotNull
List> getChecks();
// -------------------------------------------------------------------------
// XXX: Expressions based on this table
// -------------------------------------------------------------------------
/**
* Create a qualified asterisk expression from this table
* (table.*) for use with SELECT.
*
* When using an asterisk, jOOQ will let the database server define the
* order of columns, as well as which columns are included in the result
* set. If using jOOQ with generated code, this may conflict with the column
* set and its ordering as defined at code generation time, meaning columns
* may be in a different order, there may be fewer or more columns than
* expected. It is usually better to list columns explicitly.
*
* @see DSL#asterisk()
*/
@NotNull
@Support
QualifiedAsterisk asterisk();
// -------------------------------------------------------------------------
// XXX: Aliasing clauses
// -------------------------------------------------------------------------
/**
* Create an alias for this table.
*
* 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!
*
* This method works both to alias the table as well as alias the table in
* its {@link SelectField} form via the {@link SelectField#as(String)}
* override. In order to alias only the projected table expression, use
* {@link DSL#field(SelectField)} to wrap this table into a {@link Field}
* first.
*
* @param alias The alias name
* @return The table alias
*/
@Override
@NotNull
@Support
Table 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 {@link 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
*
*
* @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 as(String alias, String... fieldAliases);
/**
* Create an alias for this table and its fields.
*
* 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!
*
*
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
*
*
* @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 as(String alias, Collection fieldAliases);
/**
* Create an alias for this table and its fields.
*
* 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:
*
*
* MY_TABLE.as("t1", f ->"prefix_" + f.getName());
*
*
* @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(forRemoval = true, since = "3.14")
@NotNull
@Support
Table as(String alias, Function, ? extends String> aliasFunction);
/**
* Create an alias for this table and its fields.
*
* 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:
*
*
* MY_TABLE.as("t1", (f, i) ->"column" + i);
*
*
* @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(forRemoval = true, since = "3.14")
@NotNull
@Support
Table as(String alias, BiFunction, ? super Integer, ? extends String> aliasFunction);
/**
* Create an alias for this table.
*
* 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.
*
* If the argument {@link Name#getName()} is qualified, then the
* {@link Name#last()} part will be used.
*
* This method works both to alias the table as well as alias the table in
* its {@link SelectField} form via the {@link SelectField#as(String)}
* override. In order to alias only the projected table expression, use
* {@link DSL#field(SelectField)} to wrap this table into a {@link Field}
*
* @param alias The alias name
* @return The table alias
*/
@Override
@NotNull
@Support
Table as(Name alias);
/**
* Create an alias for this table and its fields.
*
* 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.
*
* If the argument {@link Name#getName()} is qualified, then the
* {@link 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
*
*
* @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 as(Name alias, Name... fieldAliases);
/**
* Create an alias for this table and its fields.
*
* 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.
*
* If the argument {@link Name#getName()} is qualified, then the
* {@link 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
*
*
* @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 as(Name alias, Collection fieldAliases);
/**
* Create an alias for this table and its fields.
*
* 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:
*
*
* MY_TABLE.as("t1", f ->"prefix_" + f.getName());
*
*
* @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(forRemoval = true, since = "3.14")
@NotNull
@Support
Table as(Name alias, Function, ? extends Name> aliasFunction);
/**
* Create an alias for this table and its fields.
*
* 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:
*
*
* MY_TABLE.as("t1", (f, i) ->"column" + i);
*
*
* @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(forRemoval = true, since = "3.14")
@NotNull
@Support
Table as(Name alias, BiFunction, ? super Integer, ? extends Name> aliasFunction);
/**
* 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 as(Table otherTable);
/**
* 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 as(Table otherTable, Field... otherFields);
/**
* 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 as(Table otherTable, Collection> otherFields);
/**
* Create an alias for this table and its fields.
*
* 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:
*
*
* MY_TABLE.as(MY_OTHER_TABLE, f ->MY_OTHER_TABLE.field(f));
*
*
* @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(forRemoval = true, since = "3.14")
@NotNull
@Support
Table as(Table otherTable, Function, ? extends Field> aliasFunction);
/**
* Create an alias for this table and its fields.
*
* 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:
*
*
* MY_TABLE.as("t1", (f, i) ->"column" + i);
*
*
* @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(forRemoval = true, since = "3.14")
@NotNull
@Support
Table as(Table otherTable, BiFunction, ? super Integer, ? extends Field> aliasFunction);
// -------------------------------------------------------------------------
// XXX: WHERE clauses on tables
// -------------------------------------------------------------------------
/**
* Add a WHERE clause to the table, connecting them with each
* other with {@link Operator#AND}.
*
* 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 where(Condition condition);
/**
* Add a WHERE clause to the table, connecting them with each
* other with {@link Operator#AND}.
*
* 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 where(Condition... conditions);
/**
* Add a WHERE clause to the table, connecting them with each
* other with {@link Operator#AND}.
*
* 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 where(Collection 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 {@link Condition}. If
* syntactically reasonable, the derived table may be inlined to the query
* that selects from the resulting table.
*/
@NotNull
@Support
Table where(Field 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 {@link 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 DSL#condition(SQL)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 {@link 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 DSL#condition(String)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 {@link 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 DSL#condition(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 {@link 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 DSL#condition(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 {@link Condition}. If
* syntactically reasonable, the derived table may be inlined to the query
* that selects from the resulting table.
*/
@NotNull
@Support
Table 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 {@link Condition}. If
* syntactically reasonable, the derived table may be inlined to the query
* that selects from the resulting table.
*/
@NotNull
@Support
Table whereNotExists(Select select);
// -------------------------------------------------------------------------
// XXX: JOIN clauses on tables
// -------------------------------------------------------------------------
/**
* Join a table to this table using a {@link JoinType}
*
* Depending on the JoinType, 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. 1 = 1
* condition will be rendered
*/
@NotNull
@Support
TableOptionalOnStep join(TableLike table, JoinType type);
/**
* INNER JOIN a table to this table.
*
* A synonym for {@link #innerJoin(TableLike)}.
*
* @see #innerJoin(TableLike)
*/
@NotNull
@Support
TableOnStep join(TableLike table);
/**
* INNER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(SQL)
* @see #innerJoin(SQL)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TableOnStep join(SQL sql);
/**
* INNER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(String)
* @see #innerJoin(String)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TableOnStep join(String sql);
/**
* INNER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see #innerJoin(String, Object...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TableOnStep join(String sql, Object... bindings);
/**
* INNER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see #innerJoin(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TableOnStep join(String sql, QueryPart... parts);
/**
* INNER JOIN a table to this table.
*
* A synonym for {@link #innerJoin(Name)}.
*
* @see DSL#table(Name)
* @see #innerJoin(Name)
*/
@NotNull
@Support
@PlainSQL
TableOnStep join(Name name);
/**
* INNER JOIN a table to this table.
*/
@NotNull
@Support
TableOnStep 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TableOnStep 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TableOnStep 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TableOnStep 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TableOnStep innerJoin(String sql, QueryPart... parts);
/**
* INNER JOIN a table to this table.
*
* @see DSL#table(Name)
*/
@NotNull
@Support
TableOnStep innerJoin(Name name);
/**
* LEFT OUTER JOIN a table to this table.
*
* A synonym for {@link #leftOuterJoin(TableLike)}.
*
* @see #leftOuterJoin(TableLike)
*/
@NotNull
@Support
TablePartitionByStep leftJoin(TableLike table);
/**
* LEFT OUTER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(SQL)
* @see #leftOuterJoin(SQL)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep leftJoin(SQL sql);
/**
* LEFT OUTER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(String)
* @see #leftOuterJoin(String)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep leftJoin(String sql);
/**
* LEFT OUTER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see #leftOuterJoin(String, Object...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep leftJoin(String sql, Object... bindings);
/**
* LEFT OUTER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see #leftOuterJoin(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep leftJoin(String sql, QueryPart... parts);
/**
* LEFT OUTER JOIN a table to this table.
*
* A synonym for {@link #leftOuterJoin(Name)}.
*
* @see DSL#table(Name)
* @see #leftOuterJoin(Name)
*/
@NotNull
@Support
TablePartitionByStep leftJoin(Name name);
/**
* LEFT OUTER JOIN a table to this table.
*/
@NotNull
@Support
TablePartitionByStep 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep leftOuterJoin(String sql, QueryPart... parts);
/**
* LEFT OUTER JOIN a table to this table.
*
* @see DSL#table(Name)
* @see SQL
*/
@NotNull
@Support
TablePartitionByStep leftOuterJoin(Name name);
/**
* RIGHT OUTER JOIN a table to this table.
*
* A synonym for {@link #rightOuterJoin(TableLike)}.
*
* This is only possible where the underlying RDBMS supports it.
*
* @see #rightOuterJoin(TableLike)
*/
@NotNull
@Support
TablePartitionByStep rightJoin(TableLike table);
/**
* RIGHT OUTER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(SQL)
* @see #rightOuterJoin(SQL)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep rightJoin(SQL sql);
/**
* RIGHT OUTER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(String)
* @see #rightOuterJoin(String)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep rightJoin(String sql);
/**
* RIGHT OUTER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see #rightOuterJoin(String, Object...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep rightJoin(String sql, Object... bindings);
/**
* RIGHT OUTER JOIN a table to this table.
*
* A synonym for {@link #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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see #rightOuterJoin(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep rightJoin(String sql, QueryPart... parts);
/**
* RIGHT OUTER JOIN a table to this table.
*
* A synonym for {@link #rightOuterJoin(Name)}.
*
* This is only possible where the underlying RDBMS supports it
*
* @see DSL#table(Name)
* @see #rightOuterJoin(Name)
*/
@NotNull
@Support
TablePartitionByStep rightJoin(Name name);
/**
* RIGHT OUTER JOIN a table to this table.
*
* This is only possible where the underlying RDBMS supports it
*/
@NotNull
@Support
TablePartitionByStep 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
TablePartitionByStep rightOuterJoin(String sql, QueryPart... parts);
/**
* RIGHT OUTER JOIN a table to this table.
*
* This is only possible where the underlying RDBMS supports it
*
* @see DSL#table(Name)
*/
@NotNull
@Support
TablePartitionByStep rightOuterJoin(Name name);
/**
* FULL OUTER JOIN a table to this table.
*
* A synonym for {@link #fullOuterJoin(TableLike)}.
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
TablePartitionByStep fullJoin(TableLike table);
/**
* FULL OUTER JOIN a table to this table.
*
* A synonym for {@link #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!
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
TablePartitionByStep fullJoin(SQL sql);
/**
* FULL OUTER JOIN a table to this table.
*
* A synonym for {@link #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!
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
TablePartitionByStep fullJoin(String sql);
/**
* FULL OUTER JOIN a table to this table.
*
* A synonym for {@link #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!
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
TablePartitionByStep fullJoin(String sql, Object... bindings);
/**
* FULL OUTER JOIN a table to this table.
*
* A synonym for {@link #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!
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
TablePartitionByStep fullJoin(String sql, QueryPart... parts);
/**
* FULL OUTER JOIN a table to this table.
*
* A synonym for {@link #fullOuterJoin(Name)}.
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
TablePartitionByStep fullJoin(Name name);
/**
* FULL OUTER JOIN a table to this table.
*
* This is only possible where the underlying RDBMS supports it
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
TablePartitionByStep 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
TablePartitionByStep 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
TablePartitionByStep 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
TablePartitionByStep 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
TablePartitionByStep fullOuterJoin(String sql, QueryPart... parts);
/**
* FULL OUTER JOIN a table to this table.
*
* This is only possible where the underlying RDBMS supports it
*
* @see DSL#table(Name)
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
TablePartitionByStep 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
*
*/
@NotNull
@Support
Table 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 DSL#table(Name)
*/
@NotNull
@Support
Table 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.
*/
@NotNull
@Support
Table 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 DSL#table(Name)
*/
@NotNull
@Support
Table 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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.
*/
@NotNull
@Support
Table 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support
@PlainSQL
Table 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 DSL#table(Name)
*/
@NotNull
@Support
@PlainSQL
Table 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.
*/
@NotNull
@Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE, YUGABYTEDB })
Table 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(Name)
*/
@NotNull
@Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE, YUGABYTEDB })
Table 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.
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
Table 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(Name)
*/
@NotNull
@Support({ FIREBIRD, HSQLDB, POSTGRES, SQLITE, YUGABYTEDB })
Table naturalFullOuterJoin(Name name);
// -------------------------------------------------------------------------
// XXX: APPLY clauses on tables
// -------------------------------------------------------------------------
/**
* CROSS APPLY a table to this table.
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
Table 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
@PlainSQL
Table crossApply(String sql, QueryPart... parts);
/**
* CROSS APPLY a table to this table.
*
* @see DSL#table(Name)
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
Table crossApply(Name name);
/**
* OUTER APPLY a table to this table.
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
Table 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
@PlainSQL
Table 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
@PlainSQL
Table outerApply(String sql, QueryPart... parts);
/**
* OUTER APPLY a table to this table.
*
* @see DSL#table(Name)
*/
@NotNull
@Support({ FIREBIRD, POSTGRES, YUGABYTEDB })
Table outerApply(Name name);
/**
* STRAIGHT_JOIN a table to this table.
*/
@NotNull
@Support({ MARIADB, MYSQL })
TableOnStep 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 DSL#table(SQL)
* @see SQL
*/
@NotNull
@Support({ MARIADB, MYSQL })
@PlainSQL
TableOnStep 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 DSL#table(String)
* @see SQL
*/
@NotNull
@Support({ MARIADB, MYSQL })
@PlainSQL
TableOnStep 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 DSL#table(String, Object...)
* @see DSL#sql(String, Object...)
* @see SQL
*/
@NotNull
@Support({ MARIADB, MYSQL })
@PlainSQL
TableOnStep 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 DSL#table(String, QueryPart...)
* @see DSL#sql(String, QueryPart...)
* @see SQL
*/
@NotNull
@Support({ MARIADB, MYSQL })
@PlainSQL
TableOnStep straightJoin(String sql, QueryPart... parts);
/**
* STRAIGHT_JOIN a table to this table.
*
* @see DSL#table(Name)
*/
@NotNull
@Support({ MARIADB, MYSQL })
@PlainSQL
TableOnStep straightJoin(Name name);
// -------------------------------------------------------------------------
// Generic predicates
// -------------------------------------------------------------------------
/**
* The EQ operator.
*/
@NotNull
@Support
Condition eq(Table arg2);
/**
* The