UpdatableTableImpl (jOOQ 2.6.1 API)

java.lang.Object
- org.jooq.impl.TableImpl<R>
- - org.jooq.impl.UpdatableTableImpl<R>

All Implemented Interfaces:

Serializable, Comparable<NamedQueryPart>, Adapter, AliasProvider<Table<R>>, Attachable, FieldProvider, NamedQueryPart, QueryPart, QueryPartInternal, SchemaProvider, Table<R>, TableLike<R>, Type<R>, Updatable<R>, UpdatableTable<R>
```
public class UpdatableTableImpl<R extends Record>
extends TableImpl<R>
implements UpdatableTable<R>
```
A table implementation for a table holding a primary key
This type is for JOOQ INTERNAL USE only. Do not reference directly

Author:

Lukas Eder

See Also:
Serialized Form

Constructor Summary

Constructors
Constructor and Description
`UpdatableTableImpl(String name)`
`UpdatableTableImpl(String name, Schema schema)`
`UpdatableTableImpl(String name, Schema schema, Table<R> aliased)`

Method Summary

Methods
Modifier and Type	Method and Description
`Table<R>`	`asTable()` The underlying table representation of this object This method is useful for things like `SELECT * FROM (SELECT * FROM x WHERE x.a = '1') WHERE ...`
`Table<R>`	`asTable(String alias)` The underlying aliased table representation of this object This method is useful for things like `SELECT * FROM (SELECT * FROM x WHERE x.a = '1') [alias] WHERE ...`
`void`	`attach(Configuration configuration)` Deprecated.
`int`	`compareTo(NamedQueryPart that)`
`protected Factory`	`create()` Internal convenience method
`protected Factory`	`create(Configuration configuration)` Internal convenience method
`protected static <R extends Record,T> TableField<R,T>`	`createField(String name, DataType<T> type, Table<R> table)` Subclasses may call this method to create `TableField` objects that are linked to this table.
`Table<Record>`	`crossJoin(String sql)` `CROSS JOIN` a table to this table.
`Table<Record>`	`crossJoin(String sql, Object... bindings)` `CROSS JOIN` a table to this table.
`Table<Record>`	`crossJoin(String sql, QueryPart... parts)` `CROSS JOIN` a table to this table.
`Table<Record>`	`crossJoin(TableLike<?> table)` `CROSS JOIN` a table to this table.
`boolean`	`declaresFields()` Subclasses may override this
`DivideByOnStep`	`divideBy(Table<?> divisor)` Create a new `TABLE` reference from this table, applying relational division.
`boolean`	`equals(Object that)`
`TableOnStep`	`fullOuterJoin(String sql)` `FULL OUTER JOIN` a table to this table.
`TableOnStep`	`fullOuterJoin(String sql, Object... bindings)` `FULL OUTER JOIN` a table to this table.
`TableOnStep`	`fullOuterJoin(String sql, QueryPart... parts)` `FULL OUTER JOIN` a table to this table.
`TableOnStep`	`fullOuterJoin(TableLike<?> table)` `FULL OUTER JOIN` a table to this table.
`List<Object>`	`getBindValues()` This method is also declared as `Query.getBindValues()` Retrieve the bind values that will be bound by this `QueryPart` This method is exposed publicly in `Query.getBindValues()`
`SQLDialect`	`getDialect()` Deprecated.
`<T> Field<T>`	`getField(Field<T> field)` Get a specific field from this field provider.
`Field<?>`	`getField(int index)` Get a specific field from this field provider.
`Field<?>`	`getField(String name)` Get a specific field from this field provider.
`List<Field<?>>`	`getFields()`
`Identity<R,? extends Number>`	`getIdentity()` Retrieve the table's `IDENTITY` information, if available.
`int`	`getIndex(Field<?> field)` Get a fields index from this field provider
`List<UniqueKey<R>>`	`getKeys()` Retrieve all of the table's unique keys.
`UniqueKey<R>`	`getMainKey()` Retrieve the table's main unique key.
`String`	`getName()` The name of this query part
`Param<?>`	`getParam(String name)` This method is also declared as `Query.getParam(String)` Retrieve a named parameter that will be bound by this `QueryPart` This method is exposed publicly in `Query.getParam(String)`
`Map<String,Param<?>>`	`getParams()` This method is also declared as `Query.getParams()` Retrieve the named parameters that will be bound by this `QueryPart` This method is exposed publicly in `Query.getParams()`
`TableField<R,? extends Date>`	`getRecordTimestamp()` 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.
`TableField<R,? extends Number>`	`getRecordVersion()` 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.
`List<ForeignKey<R,?>>`	`getReferences()` Get the list of `FOREIGN KEY`'s of this table
`<O extends Record> List<ForeignKey<O,R>>`	`getReferencesFrom(Table<O> other)` Get a list of `FOREIGN KEY`'s of a specific table, referencing a this table.
`<O extends Record> List<ForeignKey<R,O>>`	`getReferencesTo(Table<O> other)` Get a list of `FOREIGN KEY`'s of this table, referencing a specific table.
`Schema`	`getSchema()`
`String`	`getSQL()` This method is also declared as `Query.getSQL()` Retrieve the SQL that will be rendered by this `QueryPart` This method is exposed publicly in `Query.getSQL()`
`String`	`getSQL(boolean inline)` This method is also declared as `Query.getSQL(boolean)` Retrieve the SQL that will be rendered by this `QueryPart` This method is exposed publicly in `Query.getSQL(boolean)`
`int`	`hashCode()`
`<I> I`	`internalAPI(Class<I> internalType)` Adapt to an internal type assuming its functionality This is for JOOQ INTERNAL USE only.
`TableOnStep`	`join(String sql)` `INNER JOIN` a table to this table.
`TableOnStep`	`join(String sql, Object... bindings)` `INNER JOIN` a table to this table.
`TableOnStep`	`join(String sql, QueryPart... parts)` `INNER JOIN` a table to this table.
`TableOnStep`	`join(TableLike<?> table)` `INNER JOIN` a table to this table.
`TableOptionalOnStep`	`join(TableLike<?> table, JoinType type)` 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.
`TablePartitionByStep`	`leftOuterJoin(String sql)` `LEFT OUTER JOIN` a table to this table.
`TablePartitionByStep`	`leftOuterJoin(String sql, Object... bindings)` `LEFT OUTER JOIN` a table to this table.
`TablePartitionByStep`	`leftOuterJoin(String sql, QueryPart... parts)` `LEFT OUTER JOIN` a table to this table.
`TablePartitionByStep`	`leftOuterJoin(TableLike<?> table)` `LEFT OUTER JOIN` a table to this table.
`Table<Record>`	`naturalJoin(String sql)` `NATURAL JOIN` a table to this table.
`Table<Record>`	`naturalJoin(String sql, Object... bindings)` `NATURAL JOIN` a table to this table.
`Table<Record>`	`naturalJoin(String sql, QueryPart... parts)` `NATURAL JOIN` a table to this table.
`Table<Record>`	`naturalJoin(TableLike<?> table)` `NATURAL JOIN` a table to this table.
`Table<Record>`	`naturalLeftOuterJoin(String sql)` `NATURAL LEFT OUTER JOIN` a table to this table.
`Table<Record>`	`naturalLeftOuterJoin(String sql, Object... bindings)` `NATURAL LEFT OUTER JOIN` a table to this table.
`Table<Record>`	`naturalLeftOuterJoin(String sql, QueryPart... parts)` `NATURAL LEFT OUTER JOIN` a table to this table.
`Table<Record>`	`naturalLeftOuterJoin(TableLike<?> table)` `NATURAL LEFT OUTER JOIN` a table to this table.
`Table<Record>`	`naturalRightOuterJoin(String sql)` `NATURAL RIGHT OUTER JOIN` a table to this table.
`Table<Record>`	`naturalRightOuterJoin(String sql, Object... bindings)` `NATURAL RIGHT OUTER JOIN` a table to this table.
`Table<Record>`	`naturalRightOuterJoin(String sql, QueryPart... parts)` `NATURAL RIGHT OUTER JOIN` a table to this table.
`Table<Record>`	`naturalRightOuterJoin(TableLike<?> table)` `NATURAL RIGHT OUTER JOIN` a table to this table.
`PivotForStep`	`pivot(Collection<? extends Field<?>> aggregateFunctions)` Create a new `TABLE` reference from this table, pivoting it into another form For more details, see `Table.pivot(Field...)`
`PivotForStep`	`pivot(Field<?>... aggregateFunctions)` Create a new `TABLE` reference from this table, pivoting it into another form This has been observed to work with `SQLDialect.ORACLE` `SQLDialect.SQLSERVER` (not yet officially supported) Other dialects by using some means of simulation (not yet officially supported)
`TablePartitionByStep`	`rightOuterJoin(String sql)` `RIGHT OUTER JOIN` a table to this table.
`TablePartitionByStep`	`rightOuterJoin(String sql, Object... bindings)` `RIGHT OUTER JOIN` a table to this table.
`TablePartitionByStep`	`rightOuterJoin(String sql, QueryPart... parts)` `RIGHT OUTER JOIN` a table to this table.
`TablePartitionByStep`	`rightOuterJoin(TableLike<?> table)` `RIGHT OUTER JOIN` a table to this table.
`String`	`toString()`
`protected DataAccessException`	`translate(String sql, SQLException e)` Internal convenience method
`protected DataAccessException`	`translate(String task, String sql, SQLException e)` Deprecated. - 2.3.0 - Do not reuse

Methods inherited from class org.jooq.impl.TableImpl
as, bind, declaresTables, getFieldList, getRecordType, toSQL

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.jooq.QueryPart
attach

Methods inherited from interface org.jooq.Adapter
internalAPI

Methods inherited from interface java.lang.Comparable
compareTo

Methods inherited from interface org.jooq.FieldProvider
getField, getField, getField, getFields, getIndex

Methods inherited from interface org.jooq.TableLike
asTable, asTable

- Constructor Detail
  - UpdatableTableImpl
```
public UpdatableTableImpl(String name)
```
  - UpdatableTableImpl
```
public UpdatableTableImpl(String name,
                  Schema schema)
```
  - UpdatableTableImpl
```
public UpdatableTableImpl(String name,
                  Schema schema,
                  Table<R> aliased)
```
- Method Detail
  - getMainKey
```
public UniqueKey<R> getMainKey()
```
    Retrieve the table's main unique key. If there exists a PRIMARY KEY in the table, the PRIMARY KEY is returned. Otherwise, the most suitable UNIQUE KEY is returned.
    Subclasses should override this method
    
    Specified by:
    
    getMainKey in interface UpdatableTable<R extends Record>
    
    Returns:
    The main key. This is never null because UpdatableTable's always have at least one key.
  - getKeys
```
public List<UniqueKey<R>> getKeys()
```
    Retrieve all of the table's unique keys.
    Subclasses should override this method
    
    Specified by:
    
    getKeys in interface UpdatableTable<R extends Record>
    
    Returns:
    All keys. This is never null or empty, because UpdatableTable's always have at least one key. This method returns an unmodifiable list.
  - getRecordVersion
```
public TableField<R,? extends Number> getRecordVersion()
```
    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.
    Subclasses may override this method
    
    Specified by:
    
    getRecordVersion in interface UpdatableTable<R extends Record>
    
    Returns:
    The "version" field, or null, if this table has no "version" field.
    See Also:
    UpdatableTable.getRecordTimestamp(), UpdatableRecord.store(), UpdatableRecord.delete(), Settings.isExecuteWithOptimisticLocking()
  - getRecordTimestamp
```
public TableField<R,? extends Date> getRecordTimestamp()
```
    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.
    Subclasses may override this method
    
    Specified by:
    
    getRecordTimestamp in interface UpdatableTable<R extends Record>
    
    Returns:
    The "timestamp" field, or null, if this table has no "timestamp" field.
    See Also:
    UpdatableTable.getRecordVersion(), UpdatableRecord.store(), UpdatableRecord.delete(), Settings.isExecuteWithOptimisticLocking()
  - getReferencesFrom
```
public final <O extends Record> List<ForeignKey<O,R>> getReferencesFrom(Table<O> other)
```
    Description copied from interface: UpdatableTable
    
    Get a list of FOREIGN KEY's of a specific table, referencing a this table.
    
    Specified by:
    
    getReferencesFrom in interface UpdatableTable<R extends Record>
    
    Type Parameters:
    O - The other table's record type
    Parameters:
    other - The other table of the foreign key relationship
    
    Returns:
    Some other table's FOREIGN KEY's towards an this table. This is never null. This method returns an unmodifiable list.
  - asTable
```
public final Table<R> asTable()
```
    Description copied from interface: TableLike
    
    The underlying table representation of this object
    This method is useful for things like SELECT * FROM (SELECT * FROM x WHERE x.a = '1') WHERE ...
    
    Specified by:
    
    asTable in interface TableLike<R extends Record>
  - asTable
```
public final Table<R> asTable(String alias)
```
    Description copied from interface: TableLike
    
    The underlying aliased table representation of this object
    This method is useful for things like SELECT * FROM (SELECT * FROM x WHERE x.a = '1') [alias] WHERE ...
    
    Specified by:
    
    asTable in interface TableLike<R extends Record>
  - getIdentity
```
public Identity<R,? extends Number> getIdentity()
```
    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 simulated by triggers cannot be formally detected.
    Subclasses should override this method
    
    Specified by:
    
    getIdentity in interface Table<R extends Record>
    
    Returns:
    The table's IDENTITY information, or null, if no such information is available.
  - getReferences
```
public List<ForeignKey<R,?>> getReferences()
```
    Get the list of FOREIGN KEY's of this table
    Subclasses should override this method
    
    Specified by:
    
    getReferences in interface Table<R extends Record>
    
    Returns:
    This table's FOREIGN KEY's. This is never null.
  - getReferencesTo
```
public final <O extends Record> List<ForeignKey<R,O>> getReferencesTo(Table<O> other)
```
    Get a list of FOREIGN KEY's of this table, referencing a specific table.
    
    Specified by:
    
    getReferencesTo in interface Table<R extends Record>
    
    Type Parameters:
    O - The other table's record type
    Parameters:
    other - The other table of the foreign key relationship
    
    Returns:
    This table's FOREIGN KEY's towards an other table. This is never null.
  - createField
```
protected static final <R extends Record,T> TableField<R,T> createField(String name,
                                               DataType<T> type,
                                               Table<R> table)
```
    Subclasses may call this method to create TableField objects that are linked to this table.
    
    Parameters:
    name - The name of the field (case-sensitive!)
    type - The data type of the field
  - pivot
```
public final PivotForStep pivot(Field<?>... aggregateFunctions)
```
    Description copied from interface: Table
    Create a new TABLE reference from this table, pivoting it into another form
    This has been observed to work with
    - SQLDialect.ORACLE
    - SQLDialect.SQLSERVER (not yet officially supported)
    - Other dialects by using some means of simulation (not yet officially supported)
    Specified by:
    
    pivot in interface Table<R extends Record>
    
    Parameters:
    aggregateFunctions - The aggregate functions used for pivoting.
    
    Returns:
    A DSL object to create the PIVOT expression
  - pivot
```
public final PivotForStep pivot(Collection<? extends Field<?>> aggregateFunctions)
```
    Description copied from interface: Table
    
    Create a new TABLE reference from this table, pivoting it into another form
    For more details, see Table.pivot(Field...)
    
    Specified by:
    
    pivot in interface Table<R extends Record>
    
    Parameters:
    aggregateFunctions - The aggregate functions used for pivoting.
    
    Returns:
    A DSL object to create the PIVOT expression
    See Also:
    Table.pivot(Field...)
  - divideBy
```
public final DivideByOnStep divideBy(Table<?> divisor)
```
    Description copied from interface: Table
    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
    Specified by:
    
    divideBy in interface Table<R extends Record>
  - join
```
public TableOptionalOnStep join(TableLike<?> table,
                       JoinType type)
```
    Description copied from interface: Table
    
    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 Factory.trueCondition(), i.e. 1 = 1 condition will be rendered
    
    Specified by:
    
    join in interface Table<R extends Record>
  - join
```
public final TableOnStep join(TableLike<?> table)
```
    Description copied from interface: Table
    
    INNER JOIN a table to this table.
    
    Specified by:
    
    join in interface Table<R extends Record>
  - join
```
public final TableOnStep join(String sql)
```
    Description copied from interface: 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!
    
    Specified by:
    
    join in interface Table<R extends Record>
    
    See Also:
    Factory.table(String)
  - join
```
public final TableOnStep join(String sql,
               Object... bindings)
```
    Description copied from interface: 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!
    
    Specified by:
    
    join in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, Object...)
  - join
```
public final TableOnStep join(String sql,
               QueryPart... parts)
```
    Description copied from interface: 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!
    
    Specified by:
    
    join in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, QueryPart...)
  - leftOuterJoin
```
public final TablePartitionByStep leftOuterJoin(TableLike<?> table)
```
    Description copied from interface: Table
    
    LEFT OUTER JOIN a table to this table.
    
    Specified by:
    
    leftOuterJoin in interface Table<R extends Record>
  - leftOuterJoin
```
public final TablePartitionByStep leftOuterJoin(String sql)
```
    Description copied from interface: 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!
    
    Specified by:
    
    leftOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String)
  - leftOuterJoin
```
public final TablePartitionByStep leftOuterJoin(String sql,
                                 Object... bindings)
```
    Description copied from interface: 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!
    
    Specified by:
    
    leftOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, Object...)
  - leftOuterJoin
```
public final TablePartitionByStep leftOuterJoin(String sql,
                                 QueryPart... parts)
```
    Description copied from interface: 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!
    
    Specified by:
    
    leftOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, QueryPart...)
  - rightOuterJoin
```
public final TablePartitionByStep rightOuterJoin(TableLike<?> table)
```
    Description copied from interface: Table
    
    RIGHT OUTER JOIN a table to this table.
    This is only possible where the underlying RDBMS supports it
    
    Specified by:
    
    rightOuterJoin in interface Table<R extends Record>
  - rightOuterJoin
```
public final TablePartitionByStep rightOuterJoin(String sql)
```
    Description copied from interface: 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!
    
    Specified by:
    
    rightOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String)
  - rightOuterJoin
```
public final TablePartitionByStep rightOuterJoin(String sql,
                                  Object... bindings)
```
    Description copied from interface: 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!
    
    Specified by:
    
    rightOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, Object...)
  - rightOuterJoin
```
public final TablePartitionByStep rightOuterJoin(String sql,
                                  QueryPart... parts)
```
    Description copied from interface: 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!
    
    Specified by:
    
    rightOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, QueryPart...)
  - fullOuterJoin
```
public final TableOnStep fullOuterJoin(TableLike<?> table)
```
    Description copied from interface: Table
    
    FULL OUTER JOIN a table to this table.
    This is only possible where the underlying RDBMS supports it
    
    Specified by:
    
    fullOuterJoin in interface Table<R extends Record>
  - fullOuterJoin
```
public final TableOnStep fullOuterJoin(String sql)
```
    Description copied from interface: 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!
    
    Specified by:
    
    fullOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String)
  - fullOuterJoin
```
public final TableOnStep fullOuterJoin(String sql,
                        Object... bindings)
```
    Description copied from interface: 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!
    
    Specified by:
    
    fullOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, Object...)
  - fullOuterJoin
```
public final TableOnStep fullOuterJoin(String sql,
                        QueryPart... parts)
```
    Description copied from interface: 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!
    
    Specified by:
    
    fullOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, QueryPart...)
  - crossJoin
```
public final Table<Record> crossJoin(TableLike<?> table)
```
    Description copied from interface: Table
    CROSS JOIN a table to this table.
    If this syntax is unavailable, it is simulated with a regular INNER JOIN. The following two constructs are equivalent:
```
 A cross join B
 A join B on 1 = 1
 
```
    Specified by:
    
    crossJoin in interface Table<R extends Record>
  - crossJoin
```
public final Table<Record> crossJoin(String sql)
```
    Description copied from interface: Table
    CROSS JOIN a table to this table.
    If this syntax is unavailable, it is simulated 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!
    Specified by:
    
    crossJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String)
  - crossJoin
```
public final Table<Record> crossJoin(String sql,
                      Object... bindings)
```
    Description copied from interface: Table
    CROSS JOIN a table to this table.
    If this syntax is unavailable, it is simulated 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!
    Specified by:
    
    crossJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, Object...)
  - crossJoin
```
public final Table<Record> crossJoin(String sql,
                      QueryPart... parts)
```
    Description copied from interface: Table
    CROSS JOIN a table to this table.
    If this syntax is unavailable, it is simulated 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!
    Specified by:
    
    crossJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, QueryPart...)
  - naturalJoin
```
public final Table<Record> naturalJoin(TableLike<?> table)
```
    Description copied from interface: Table
    
    NATURAL JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate this behaviour using the information provided in this query.
    
    Specified by:
    
    naturalJoin in interface Table<R extends Record>
  - naturalJoin
```
public final Table<Record> naturalJoin(String sql)
```
    Description copied from interface: Table
    
    NATURAL JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate 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!
    
    Specified by:
    
    naturalJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String)
  - naturalJoin
```
public final Table<Record> naturalJoin(String sql,
                        Object... bindings)
```
    Description copied from interface: Table
    
    NATURAL JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate 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!
    
    Specified by:
    
    naturalJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, Object...)
  - naturalJoin
```
public final Table<Record> naturalJoin(String sql,
                        QueryPart... parts)
```
    Description copied from interface: Table
    
    NATURAL JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate 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!
    
    Specified by:
    
    naturalJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, QueryPart...)
  - naturalLeftOuterJoin
```
public final Table<Record> naturalLeftOuterJoin(TableLike<?> table)
```
    Description copied from interface: Table
    
    NATURAL LEFT OUTER JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate this behaviour using the information provided in this query.
    
    Specified by:
    
    naturalLeftOuterJoin in interface Table<R extends Record>
  - naturalLeftOuterJoin
```
public final Table<Record> naturalLeftOuterJoin(String sql)
```
    Description copied from interface: Table
    
    NATURAL LEFT OUTER JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate 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!
    
    Specified by:
    
    naturalLeftOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String)
  - naturalLeftOuterJoin
```
public final Table<Record> naturalLeftOuterJoin(String sql,
                                 Object... bindings)
```
    Description copied from interface: Table
    
    NATURAL LEFT OUTER JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate 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!
    
    Specified by:
    
    naturalLeftOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, Object...)
  - naturalLeftOuterJoin
```
public final Table<Record> naturalLeftOuterJoin(String sql,
                                 QueryPart... parts)
```
    Description copied from interface: Table
    
    NATURAL LEFT OUTER JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate 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!
    
    Specified by:
    
    naturalLeftOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, QueryPart...)
  - naturalRightOuterJoin
```
public final Table<Record> naturalRightOuterJoin(TableLike<?> table)
```
    Description copied from interface: Table
    
    NATURAL RIGHT OUTER JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate this behaviour using the information provided in this query.
    
    Specified by:
    
    naturalRightOuterJoin in interface Table<R extends Record>
  - naturalRightOuterJoin
```
public final Table<Record> naturalRightOuterJoin(String sql)
```
    Description copied from interface: Table
    
    NATURAL RIGHT OUTER JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate 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!
    
    Specified by:
    
    naturalRightOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String)
  - naturalRightOuterJoin
```
public final Table<Record> naturalRightOuterJoin(String sql,
                                  Object... bindings)
```
    Description copied from interface: Table
    
    NATURAL RIGHT OUTER JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate 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!
    
    Specified by:
    
    naturalRightOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, Object...)
  - naturalRightOuterJoin
```
public final Table<Record> naturalRightOuterJoin(String sql,
                                  QueryPart... parts)
```
    Description copied from interface: Table
    
    NATURAL RIGHT OUTER JOIN a table to this table.
    If this is not supported by your RDBMS, then jOOQ will try to simulate 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!
    
    Specified by:
    
    naturalRightOuterJoin in interface Table<R extends Record>
    
    See Also:
    Factory.table(String, QueryPart...)
  - hashCode
```
public int hashCode()
```
  - getFields
```
public final List<Field<?>> getFields()
```
    Specified by:
    
    getFields in interface FieldProvider
    
    Returns:
    All available fields
  - getField
```
public final <T> Field<T> getField(Field<T> field)
```
    Description copied from interface: FieldProvider
    
    Get a specific field from this field provider.
    Usually, this will return the field itself. However, if this is an aliased table, the field will be aliased accordingly.
    
    Specified by:
    
    getField in interface FieldProvider
    
    Type Parameters:
    T - The generic field type
    Parameters:
    field - The field to fetch
    
    Returns:
    The field itself or an aliased field
  - getField
```
public final Field<?> getField(String name)
```
    Description copied from interface: FieldProvider
    
    Get a specific field from this field provider.
    
    Specified by:
    
    getField in interface FieldProvider
    
    Parameters:
    name - The field to fetch
    
    Returns:
    The field with the given name
  - getField
```
public final Field<?> getField(int index)
```
    Description copied from interface: FieldProvider
    
    Get a specific field from this field provider.
    
    Specified by:
    
    getField in interface FieldProvider
    
    Parameters:
    index - The field's index of the field to fetch
    
    Returns:
    The field with the given name
  - getIndex
```
public final int getIndex(Field<?> field)
                   throws IllegalArgumentException
```
    Description copied from interface: FieldProvider
    
    Get a fields index from this field provider
    
    Specified by:
    
    getIndex in interface FieldProvider
    
    Parameters:
    field - The field to look for
    
    Returns:
    The field's index
    
    Throws:
    
    IllegalArgumentException - if the field is not contained in this provider.
  - getSchema
```
public final Schema getSchema()
```
    Specified by:
    
    getSchema in interface SchemaProvider
    
    Returns:
    The contained schema
  - getName
```
public final String getName()
```
    Description copied from interface: NamedQueryPart
    
    The name of this query part
    
    Specified by:
    
    getName in interface NamedQueryPart
  - compareTo
```
public final int compareTo(NamedQueryPart that)
```
    Specified by:
    
    compareTo in interface Comparable<NamedQueryPart>
  - internalAPI
```
public final <I> I internalAPI(Class<I> internalType)
```
    Description copied from interface: Adapter
    Adapt to an internal type assuming its functionality
    This is for JOOQ INTERNAL USE only. If you need to access the internal API, these are the known possible interfaces:
    - QueryPartInternal: The internal API for QueryPart
    Be aware though, that the internal API may change even between minor releases.
    Specified by:
    
    internalAPI in interface Adapter
    
    Type Parameters:
    I - The internal type's generic type parameter.
    Parameters:
    internalType - The internal type
    
    Returns:
    This object wrapped by or cast to an internal type
  - attach
```
@Deprecated
public void attach(Configuration configuration)
```
    Deprecated.
    
    Description copied from interface: QueryPart
    
    Attach this object to a new Configuration
    
    Specified by:
    
    attach in interface Attachable
    
    Specified by:
    
    attach in interface QueryPart
    
    Parameters:
    configuration - A configuration or null, if you wish to detach this Attachable from its previous configuration.
  - getDialect
```
@Deprecated
public final SQLDialect getDialect()
```
    Deprecated.
    
    Description copied from interface: QueryPartInternal
    
    Reproduce the SQL dialect this QueryPart was created with
    This method is for JOOQ INTERNAL USE only. Do not reference directly
    
    Specified by:
    
    getDialect in interface QueryPartInternal
    
    Returns:
    The SQL dialect
  - getSQL
```
public final String getSQL()
```
    This method is also declared as Query.getSQL()
    Retrieve the SQL that will be rendered by this QueryPart
    This method is exposed publicly in Query.getSQL()
    
    Specified by:
    
    getSQL in interface QueryPartInternal
  - getSQL
```
public final String getSQL(boolean inline)
```
    This method is also declared as Query.getSQL(boolean)
    Retrieve the SQL that will be rendered by this QueryPart
    This method is exposed publicly in Query.getSQL(boolean)
    
    Specified by:
    
    getSQL in interface QueryPartInternal
  - getBindValues
```
public final List<Object> getBindValues()
```
    This method is also declared as Query.getBindValues()
    Retrieve the bind values that will be bound by this QueryPart
    This method is exposed publicly in Query.getBindValues()
    
    Specified by:
    
    getBindValues in interface QueryPartInternal
  - getParams
```
public final Map<String,Param<?>> getParams()
```
    This method is also declared as Query.getParams()
    Retrieve the named parameters that will be bound by this QueryPart
    This method is exposed publicly in Query.getParams()
    
    Specified by:
    
    getParams in interface QueryPartInternal
  - getParam
```
public final Param<?> getParam(String name)
```
    This method is also declared as Query.getParam(String)
    Retrieve a named parameter that will be bound by this QueryPart
    This method is exposed publicly in Query.getParam(String)
    
    Specified by:
    
    getParam in interface QueryPartInternal
  - declaresFields
```
public boolean declaresFields()
```
    Subclasses may override this
    
    Specified by:
    
    declaresFields in interface QueryPartInternal
  - equals
```
public boolean equals(Object that)
```
    Overrides:
    
    equals in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - create
```
protected final Factory create()
```
    Internal convenience method
  - create
```
protected final Factory create(Configuration configuration)
```
    Internal convenience method
  - translate
```
@Deprecated
protected final DataAccessException translate(String task,
                                       String sql,
                                       SQLException e)
```
    Deprecated. - 2.3.0 - Do not reuse
    
    Internal convenience method
  - translate
```
protected final DataAccessException translate(String sql,
                            SQLException e)
```
    Internal convenience method

Class UpdatableTableImpl<R extends Record>

Constructor Summary

Method Summary

Methods inherited from class org.jooq.impl.TableImpl

Methods inherited from class java.lang.Object

Methods inherited from interface org.jooq.Table

Methods inherited from interface org.jooq.QueryPart

Methods inherited from interface org.jooq.Adapter

Methods inherited from interface java.lang.Comparable

Methods inherited from interface org.jooq.FieldProvider

Methods inherited from interface org.jooq.TableLike

Constructor Detail

UpdatableTableImpl

UpdatableTableImpl

UpdatableTableImpl

Method Detail

getMainKey

getKeys

getRecordVersion

getRecordTimestamp

getReferencesFrom

asTable

asTable

getIdentity

getReferences

getReferencesTo

createField

pivot

pivot

divideBy

join

join

join

join

join

leftOuterJoin

leftOuterJoin

leftOuterJoin

leftOuterJoin

rightOuterJoin

rightOuterJoin

rightOuterJoin

rightOuterJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

crossJoin

crossJoin

crossJoin

crossJoin

naturalJoin

naturalJoin

naturalJoin

naturalJoin

naturalLeftOuterJoin

naturalLeftOuterJoin

naturalLeftOuterJoin

naturalLeftOuterJoin

naturalRightOuterJoin

naturalRightOuterJoin

naturalRightOuterJoin

naturalRightOuterJoin

hashCode

getFields

getField

getField

getField

getIndex

getSchema

getName

compareTo

internalAPI

attach

getDialect

getSQL

getSQL

getBindValues

getParams

getParam