public class UpdatableTableImpl<R extends Record> extends TableImpl<R> implements UpdatableTable<R>
This type is for JOOQ INTERNAL USE only. Do not reference directly
Constructor and Description |
---|
UpdatableTableImpl(String name) |
UpdatableTableImpl(String name,
Schema schema) |
UpdatableTableImpl(String name,
Schema schema,
Table<R> aliased) |
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> |
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. |
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> |
getReferencesFrom(Table<O> other)
Get a list of
FOREIGN KEY 's of a specific table, referencing
a this table. |
<O extends Record> |
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
|
as, bind, declaresTables, equals, getFieldList, getRecordType, toSQL
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
as, crossJoin, crossJoin, crossJoin, crossJoin, divideBy, fullOuterJoin, fullOuterJoin, fullOuterJoin, fullOuterJoin, getIdentity, getName, getRecordType, getReferences, getReferencesTo, getSchema, join, join, join, join, join, leftOuterJoin, leftOuterJoin, leftOuterJoin, leftOuterJoin, naturalJoin, naturalJoin, naturalJoin, naturalJoin, naturalLeftOuterJoin, naturalLeftOuterJoin, naturalLeftOuterJoin, naturalLeftOuterJoin, naturalRightOuterJoin, naturalRightOuterJoin, naturalRightOuterJoin, naturalRightOuterJoin, pivot, pivot, rightOuterJoin, rightOuterJoin, rightOuterJoin, rightOuterJoin
internalAPI
compareTo
public UpdatableTableImpl(String name)
public UniqueKey<R> getMainKey()
PRIMARY KEY
in the table, the PRIMARY KEY
is
returned. Otherwise, the most suitable UNIQUE KEY
is
returned.
Subclasses should override this method
getMainKey
in interface UpdatableTable<R extends Record>
null
because
UpdatableTable
's always have at least one key.public List<UniqueKey<R>> getKeys()
Subclasses should override this method
getKeys
in interface UpdatableTable<R extends Record>
null
or empty, because
UpdatableTable
's always have at least one key. This
method returns an unmodifiable list.public TableField<R,? extends Number> getRecordVersion()
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
getRecordVersion
in interface UpdatableTable<R extends Record>
null
, if this table has no
"version" field.UpdatableTable.getRecordTimestamp()
,
UpdatableRecord.store()
,
UpdatableRecord.delete()
,
Settings.isExecuteWithOptimisticLocking()
public TableField<R,? extends Date> getRecordTimestamp()
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
getRecordTimestamp
in interface UpdatableTable<R extends Record>
null
, if this table has no
"timestamp" field.UpdatableTable.getRecordVersion()
,
UpdatableRecord.store()
,
UpdatableRecord.delete()
,
Settings.isExecuteWithOptimisticLocking()
public final <O extends Record> List<ForeignKey<O,R>> getReferencesFrom(Table<O> other)
UpdatableTable
FOREIGN KEY
's of a specific table, referencing
a this table.getReferencesFrom
in interface UpdatableTable<R extends Record>
O
- The other table's record typeother
- The other table of the foreign key relationshipFOREIGN KEY
's towards an this
table. This is never null
. This method returns an
unmodifiable list.public final Table<R> asTable()
TableLike
This method is useful for things like
SELECT * FROM (SELECT * FROM x WHERE x.a = '1') WHERE ...
public final Table<R> asTable(String alias)
TableLike
This method is useful for things like
SELECT * FROM (SELECT * FROM x WHERE x.a = '1') [alias] WHERE ...
public Identity<R,? extends Number> getIdentity()
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
getIdentity
in interface Table<R extends Record>
IDENTITY
information, or
null
, if no such information is available.public List<ForeignKey<R,?>> getReferences()
FOREIGN KEY
's of this table
Subclasses should override this method
getReferences
in interface Table<R extends Record>
FOREIGN KEY
's. This is never
null
.public final <O extends Record> List<ForeignKey<R,O>> getReferencesTo(Table<O> other)
FOREIGN KEY
's of this table, referencing a
specific table.getReferencesTo
in interface Table<R extends Record>
O
- The other table's record typeother
- The other table of the foreign key relationshipFOREIGN KEY
's towards an other table.
This is never null
.protected static final <R extends Record,T> TableField<R,T> createField(String name, DataType<T> type, Table<R> table)
TableField
objects that
are linked to this table.name
- The name of the field (case-sensitive!)type
- The data type of the fieldpublic final PivotForStep pivot(Field<?>... aggregateFunctions)
Table
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)public final PivotForStep pivot(Collection<? extends Field<?>> aggregateFunctions)
Table
TABLE
reference from this table, pivoting it
into another form
For more details, see Table.pivot(Field...)
pivot
in interface Table<R extends Record>
aggregateFunctions
- The aggregate functions used for pivoting.PIVOT
expressionTable.pivot(Field...)
public final DivideByOnStep divideBy(Table<?> divisor)
Table
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
This has been observed to work with all dialects
public TableOptionalOnStep join(TableLike<?> table, JoinType type)
Table
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
public final TableOnStep join(TableLike<?> table)
Table
INNER JOIN
a table to this table.public final TableOnStep join(String sql)
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!
join
in interface Table<R extends Record>
Factory.table(String)
public final TableOnStep join(String sql, Object... bindings)
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!
join
in interface Table<R extends Record>
Factory.table(String, Object...)
public final TableOnStep join(String sql, QueryPart... parts)
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!
join
in interface Table<R extends Record>
Factory.table(String, QueryPart...)
public final TablePartitionByStep leftOuterJoin(TableLike<?> table)
Table
LEFT OUTER JOIN
a table to this table.leftOuterJoin
in interface Table<R extends Record>
public final TablePartitionByStep leftOuterJoin(String sql)
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!
leftOuterJoin
in interface Table<R extends Record>
Factory.table(String)
public final TablePartitionByStep leftOuterJoin(String sql, Object... bindings)
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!
leftOuterJoin
in interface Table<R extends Record>
Factory.table(String, Object...)
public final TablePartitionByStep leftOuterJoin(String sql, QueryPart... parts)
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!
leftOuterJoin
in interface Table<R extends Record>
Factory.table(String, QueryPart...)
public final TablePartitionByStep rightOuterJoin(TableLike<?> table)
Table
RIGHT OUTER JOIN
a table to this table.
This is only possible where the underlying RDBMS supports it
rightOuterJoin
in interface Table<R extends Record>
public final TablePartitionByStep rightOuterJoin(String sql)
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!
rightOuterJoin
in interface Table<R extends Record>
Factory.table(String)
public final TablePartitionByStep rightOuterJoin(String sql, Object... bindings)
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!
rightOuterJoin
in interface Table<R extends Record>
Factory.table(String, Object...)
public final TablePartitionByStep rightOuterJoin(String sql, QueryPart... parts)
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!
rightOuterJoin
in interface Table<R extends Record>
Factory.table(String, QueryPart...)
public final TableOnStep fullOuterJoin(TableLike<?> table)
Table
FULL OUTER JOIN
a table to this table.
This is only possible where the underlying RDBMS supports it
fullOuterJoin
in interface Table<R extends Record>
public final TableOnStep fullOuterJoin(String sql)
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!
fullOuterJoin
in interface Table<R extends Record>
Factory.table(String)
public final TableOnStep fullOuterJoin(String sql, Object... bindings)
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!
fullOuterJoin
in interface Table<R extends Record>
Factory.table(String, Object...)
public final TableOnStep fullOuterJoin(String sql, QueryPart... parts)
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!
fullOuterJoin
in interface Table<R extends Record>
Factory.table(String, QueryPart...)
public final Table<Record> crossJoin(TableLike<?> table)
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
public final Table<Record> crossJoin(String sql)
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!
crossJoin
in interface Table<R extends Record>
Factory.table(String)
public final Table<Record> crossJoin(String sql, Object... bindings)
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!
crossJoin
in interface Table<R extends Record>
Factory.table(String, Object...)
public final Table<Record> crossJoin(String sql, QueryPart... parts)
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!
crossJoin
in interface Table<R extends Record>
Factory.table(String, QueryPart...)
public final Table<Record> naturalJoin(TableLike<?> table)
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.
naturalJoin
in interface Table<R extends Record>
public final Table<Record> naturalJoin(String sql)
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!
naturalJoin
in interface Table<R extends Record>
Factory.table(String)
public final Table<Record> naturalJoin(String sql, Object... bindings)
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!
naturalJoin
in interface Table<R extends Record>
Factory.table(String, Object...)
public final Table<Record> naturalJoin(String sql, QueryPart... parts)
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!
naturalJoin
in interface Table<R extends Record>
Factory.table(String, QueryPart...)
public final Table<Record> naturalLeftOuterJoin(TableLike<?> table)
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.
naturalLeftOuterJoin
in interface Table<R extends Record>
public final Table<Record> naturalLeftOuterJoin(String sql)
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!
naturalLeftOuterJoin
in interface Table<R extends Record>
Factory.table(String)
public final Table<Record> naturalLeftOuterJoin(String sql, Object... bindings)
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!
naturalLeftOuterJoin
in interface Table<R extends Record>
Factory.table(String, Object...)
public final Table<Record> naturalLeftOuterJoin(String sql, QueryPart... parts)
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!
naturalLeftOuterJoin
in interface Table<R extends Record>
Factory.table(String, QueryPart...)
public final Table<Record> naturalRightOuterJoin(TableLike<?> table)
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.
naturalRightOuterJoin
in interface Table<R extends Record>
public final Table<Record> naturalRightOuterJoin(String sql)
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!
naturalRightOuterJoin
in interface Table<R extends Record>
Factory.table(String)
public final Table<Record> naturalRightOuterJoin(String sql, Object... bindings)
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!
naturalRightOuterJoin
in interface Table<R extends Record>
Factory.table(String, Object...)
public final Table<Record> naturalRightOuterJoin(String sql, QueryPart... parts)
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!
naturalRightOuterJoin
in interface Table<R extends Record>
Factory.table(String, QueryPart...)
public int hashCode()
public final List<Field<?>> getFields()
getFields
in interface FieldProvider
public final <T> Field<T> getField(Field<T> field)
FieldProvider
Usually, this will return the field itself. However, if this is an aliased table, the field will be aliased accordingly.
getField
in interface FieldProvider
T
- The generic field typefield
- The field to fetchpublic final Field<?> getField(String name)
FieldProvider
getField
in interface FieldProvider
name
- The field to fetchpublic final Field<?> getField(int index)
FieldProvider
getField
in interface FieldProvider
index
- The field's index of the field to fetchpublic final int getIndex(Field<?> field) throws IllegalArgumentException
FieldProvider
getIndex
in interface FieldProvider
field
- The field to look forIllegalArgumentException
- if the field is not contained in this
provider.public final Schema getSchema()
getSchema
in interface SchemaProvider
public final String getName()
NamedQueryPart
getName
in interface NamedQueryPart
public final int compareTo(NamedQueryPart that)
compareTo
in interface Comparable<NamedQueryPart>
public final <I> I internalAPI(Class<I> internalType)
Adapter
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
internalAPI
in interface Adapter
I
- The internal type's generic type parameter.internalType
- The internal type@Deprecated public void attach(Configuration configuration)
QueryPart
Configuration
attach
in interface Attachable
attach
in interface QueryPart
configuration
- A configuration or null
, if you wish to
detach this Attachable
from its previous
configuration.@Deprecated public final SQLDialect getDialect()
QueryPartInternal
QueryPart
was created with
This method is for JOOQ INTERNAL USE only. Do not reference directly
getDialect
in interface QueryPartInternal
public final String getSQL()
Query.getSQL()
Retrieve the SQL that will be rendered by this QueryPart
This method is exposed publicly in Query.getSQL()
getSQL
in interface QueryPartInternal
public final String getSQL(boolean inline)
Query.getSQL(boolean)
Retrieve the SQL that will be rendered by this QueryPart
This method is exposed publicly in Query.getSQL(boolean)
getSQL
in interface QueryPartInternal
public final List<Object> getBindValues()
Query.getBindValues()
Retrieve the bind values that will be bound by this QueryPart
This method is exposed publicly in Query.getBindValues()
getBindValues
in interface QueryPartInternal
public final Map<String,Param<?>> getParams()
Query.getParams()
Retrieve the named parameters that will be bound by this
QueryPart
This method is exposed publicly in Query.getParams()
getParams
in interface QueryPartInternal
public final Param<?> getParam(String name)
Query.getParam(String)
Retrieve a named parameter that will be bound by this QueryPart
This method is exposed publicly in Query.getParam(String)
getParam
in interface QueryPartInternal
public boolean declaresFields()
declaresFields
in interface QueryPartInternal
protected final Factory create()
protected final Factory create(Configuration configuration)
@Deprecated protected final DataAccessException translate(String task, String sql, SQLException e)
protected final DataAccessException translate(String sql, SQLException e)
Copyright © 2013. All Rights Reserved.