|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
R
- The record type associated with this tablepublic interface Table<R extends Record>
A table to be used in queries
Method Summary | ||
---|---|---|
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. |
|
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. |
|
Identity<R,? extends Number> |
getIdentity()
Retrieve the table's IDENTITY information, if available. |
|
Class<? extends R> |
getRecordType()
|
|
List<ForeignKey<R,?>> |
getReferences()
Get the list of FOREIGN KEY 's of this table |
|
|
getReferencesTo(Table<O> other)
Get a list of FOREIGN KEY 's of this table, referencing a
specific table. |
|
Schema |
getSchema()
Get the table schema |
|
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. |
|
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 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. |
Methods inherited from interface org.jooq.NamedQueryPart |
---|
getName |
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.AliasProvider |
---|
as |
Methods inherited from interface org.jooq.TableLike |
---|
asTable, asTable |
Method Detail |
---|
Schema getSchema()
getSchema
in interface SchemaProvider
Class<? extends R> getRecordType()
getRecordType
in interface Type<R extends Record>
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.
IDENTITY
information, or
null
, if no such information is available.List<ForeignKey<R,?>> getReferences()
FOREIGN KEY
's of this table
FOREIGN KEY
's. This is never
null
.<O extends Record> List<ForeignKey<R,O>> getReferencesTo(Table<O> other)
FOREIGN KEY
's of this table, referencing a
specific table.
O
- The other table's record typeother
- The other table of the foreign key relationship
FOREIGN KEY
's towards an other table.
This is never null
.PivotForStep pivot(Field<?>... aggregateFunctions)
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)
aggregateFunctions
- The aggregate functions used for pivoting.
PIVOT
expressionPivotForStep pivot(Collection<? extends Field<?>> aggregateFunctions)
TABLE
reference from this table, pivoting it
into another form
For more details, see pivot(Field...)
aggregateFunctions
- The aggregate functions used for pivoting.
PIVOT
expressionpivot(Field...)
DivideByOnStep divideBy(Table<?> divisor)
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
TableOnStep join(TableLike<?> table)
INNER JOIN
a table to this table.
TableOnStep join(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!
Factory.table(String)
TableOnStep join(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!
Factory.table(String, Object...)
TableOnStep join(String sql, QueryPart... parts)
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!
Factory#table(String, QueryPart...)
TablePartitionByStep leftOuterJoin(TableLike<?> table)
LEFT OUTER JOIN
a table to this table.
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!
Factory.table(String)
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!
Factory.table(String, Object...)
TablePartitionByStep leftOuterJoin(String sql, QueryPart... parts)
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!
Factory#table(String, QueryPart...)
TablePartitionByStep rightOuterJoin(TableLike<?> table)
RIGHT OUTER JOIN
a table to this table.
This is only possible where the underlying RDBMS supports it
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!
Factory.table(String)
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!
Factory.table(String, Object...)
TablePartitionByStep rightOuterJoin(String sql, QueryPart... parts)
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!
Factory#table(String, QueryPart...)
TableOnStep fullOuterJoin(TableLike<?> table)
FULL OUTER JOIN
a table to this table.
This is only possible where the underlying RDBMS supports it
TableOnStep 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!
Factory.table(String)
TableOnStep 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!
Factory.table(String, Object...)
TableOnStep fullOuterJoin(String sql, QueryPart... parts)
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!
Factory#table(String, QueryPart...)
Table<Record> crossJoin(TableLike<?> 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
Table<Record> crossJoin(String sql)
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!
Factory.table(String)
Table<Record> crossJoin(String sql, Object... bindings)
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!
Factory.table(String, Object...)
Table<Record> crossJoin(String sql, QueryPart... parts)
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!
Factory#table(String, QueryPart...)
Table<Record> naturalJoin(TableLike<?> table)
NATURAL JOIN
a table to this table.
If this is not supported by your RDBMS, then jOOQ will try to simulate this behaviour using the information provided in this query.
Table<Record> naturalJoin(String sql)
NATURAL JOIN
a table to this table.
If this is not supported by your RDBMS, then jOOQ will try to 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!
Factory.table(String)
Table<Record> naturalJoin(String sql, Object... bindings)
NATURAL JOIN
a table to this table.
If this is not supported by your RDBMS, then jOOQ will try to 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!
Factory.table(String, Object...)
Table<Record> naturalJoin(String sql, QueryPart... parts)
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!
Factory#table(String, QueryPart...)
Table<Record> naturalLeftOuterJoin(TableLike<?> table)
NATURAL LEFT OUTER JOIN
a table to this table.
If this is not supported by your RDBMS, then jOOQ will try to simulate this behaviour using the information provided in this query.
Table<Record> naturalLeftOuterJoin(String sql)
NATURAL LEFT OUTER JOIN
a table to this table.
If this is not supported by your RDBMS, then jOOQ will try to 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!
Factory.table(String)
Table<Record> naturalLeftOuterJoin(String sql, Object... bindings)
NATURAL LEFT OUTER JOIN
a table to this table.
If this is not supported by your RDBMS, then jOOQ will try to 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!
Factory.table(String, Object...)
Table<Record> naturalLeftOuterJoin(String sql, QueryPart... parts)
NATURAL LEFT OUTER JOIN
a table to this table.
If this is not supported by your RDBMS, then jOOQ will try to 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!
Factory#table(String, QueryPart...)
Table<Record> naturalRightOuterJoin(TableLike<?> table)
NATURAL RIGHT OUTER JOIN
a table to this table.
If this is not supported by your RDBMS, then jOOQ will try to simulate this behaviour using the information provided in this query.
Table<Record> naturalRightOuterJoin(String sql)
NATURAL RIGHT OUTER JOIN
a table to this table.
If this is not supported by your RDBMS, then jOOQ will try to 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!
Factory.table(String)
Table<Record> naturalRightOuterJoin(String sql, Object... bindings)
NATURAL RIGHT OUTER JOIN
a table to this table.
If this is not supported by your RDBMS, then jOOQ will try to 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!
Factory.table(String, Object...)
Table<Record> naturalRightOuterJoin(String sql, QueryPart... parts)
NATURAL RIGHT OUTER JOIN
a table to this table.
If this is not supported by your RDBMS, then jOOQ will try to 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!
Factory#table(String, QueryPart...)
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |