|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface SelectJoinStep
This type is used for the Select
's DSL API when selecting generic
Record
types.
Example:
Its equivalent in jOOQ
-- get all authors' first and last names, and the number
-- of books they've written in German, if they have written
-- more than five books in German in the last three years
-- (from 2011), and sort those authors by last names
-- limiting results to the second and third row
SELECT T_AUTHOR.FIRST_NAME, T_AUTHOR.LAST_NAME, COUNT(*)
FROM T_AUTHOR
JOIN T_BOOK ON T_AUTHOR.ID = T_BOOK.AUTHOR_ID
WHERE T_BOOK.LANGUAGE = 'DE'
AND T_BOOK.PUBLISHED > '2008-01-01'
GROUP BY T_AUTHOR.FIRST_NAME, T_AUTHOR.LAST_NAME
HAVING COUNT(*) > 5
ORDER BY T_AUTHOR.LAST_NAME ASC NULLS FIRST
LIMIT 2
OFFSET 1
FOR UPDATE
OF FIRST_NAME, LAST_NAME
NO WAIT
Refer to the manual for more details
create.select(TAuthor.FIRST_NAME, TAuthor.LAST_NAME, create.count())
.from(T_AUTHOR)
.join(T_BOOK).on(TBook.AUTHOR_ID.equal(TAuthor.ID))
.where(TBook.LANGUAGE.equal("DE"))
.and(TBook.PUBLISHED.greaterThan(parseDate('2008-01-01')))
.groupBy(TAuthor.FIRST_NAME, TAuthor.LAST_NAME)
.having(create.count().greaterThan(5))
.orderBy(TAuthor.LAST_NAME.asc().nullsFirst())
.limit(2)
.offset(1)
.forUpdate()
.of(TAuthor.FIRST_NAME, TAuthor.LAST_NAME)
.noWait();
Method Summary | |
---|---|
SelectJoinStep |
crossJoin(String sql)
Convenience method to CROSS JOIN a table to the last table
added to the FROM clause using
Table.crossJoin(String)
If this syntax is unavailable, it is simulated with a regular
INNER JOIN . |
SelectJoinStep |
crossJoin(String sql,
Object... bindings)
Convenience method to CROSS JOIN a table to the last table
added to the FROM clause using
Table.crossJoin(String, Object...) |
SelectJoinStep |
crossJoin(TableLike<?> table)
Convenience method to CROSS JOIN a table to the last table
added to the FROM clause using
Table.crossJoin(TableLike)
If this syntax is unavailable, it is simulated with a regular
INNER JOIN . |
SelectOnStep |
fullOuterJoin(String sql)
Convenience method to FULL OUTER JOIN a table to the last
table added to the FROM clause using
Table.fullOuterJoin(String)
This is only possible where the underlying RDBMS supports it
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. |
SelectOnStep |
fullOuterJoin(String sql,
Object... bindings)
Convenience method to FULL OUTER JOIN a tableto the last
table added to the FROM clause using
Table.fullOuterJoin(String, Object...) |
SelectOnStep |
fullOuterJoin(TableLike<?> table)
Convenience method to FULL OUTER JOIN a table to the last
table added to the FROM clause using
Table.fullOuterJoin(TableLike)
This is only possible where the underlying RDBMS supports it |
SelectOnStep |
join(String sql)
Convenience method to INNER JOIN a table to the last table
added to the FROM clause using Table.join(String)
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. |
SelectOnStep |
join(String sql,
Object... bindings)
Convenience method to INNER JOIN a table to the last table
added to the FROM clause using
Table.join(String, Object...) |
SelectOnStep |
join(TableLike<?> table)
Convenience method to INNER JOIN a table to the last table
added to the FROM clause using Table.join(TableLike) |
SelectOnStep |
leftOuterJoin(String sql)
Convenience method to LEFT OUTER JOIN a table to the last
table added to the FROM clause using
Table.leftOuterJoin(String)
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. |
SelectOnStep |
leftOuterJoin(String sql,
Object... bindings)
Convenience method to LEFT OUTER JOIN a table to the last
table added to the FROM clause using
Table.leftOuterJoin(String, Object...) |
SelectOnStep |
leftOuterJoin(TableLike<?> table)
Convenience method to LEFT OUTER JOIN a table to the last
table added to the FROM clause using
Table.leftOuterJoin(TableLike) |
SelectJoinStep |
naturalJoin(String sql)
Convenience method to NATURAL JOIN a table to the last table
added to the FROM clause using
Table.naturalJoin(String)
Natural joins are supported by most RDBMS. |
SelectJoinStep |
naturalJoin(String sql,
Object... bindings)
Convenience method to NATURAL JOIN a table to the last table
added to the FROM clause using
Table.naturalJoin(String, Object...) |
SelectJoinStep |
naturalJoin(TableLike<?> table)
Convenience method to NATURAL JOIN a table to the last table
added to the FROM clause using
Table.naturalJoin(TableLike)
Natural joins are supported by most RDBMS. |
SelectJoinStep |
naturalLeftOuterJoin(String sql)
Convenience method to NATURAL LEFT OUTER JOIN a table to the
last table added to the FROM clause using
Table.naturalLeftOuterJoin(String)
Natural joins are supported by most RDBMS. |
SelectJoinStep |
naturalLeftOuterJoin(String sql,
Object... bindings)
Convenience method to NATURAL LEFT OUTER JOIN a table to the
last table added to the FROM clause using
Table.naturalLeftOuterJoin(String, Object...) |
SelectJoinStep |
naturalLeftOuterJoin(TableLike<?> table)
Convenience method to NATURAL LEFT OUTER JOIN a table to the
last table added to the FROM clause using
Table.naturalLeftOuterJoin(TableLike)
Natural joins are supported by most RDBMS. |
SelectJoinStep |
naturalRightOuterJoin(String sql)
Convenience method to NATURAL RIGHT OUTER JOIN a table to
the last table added to the FROM clause using
Table.naturalRightOuterJoin(String)
Natural joins are supported by most RDBMS. |
SelectJoinStep |
naturalRightOuterJoin(String sql,
Object... bindings)
Convenience method to NATURAL RIGHT OUTER JOIN a table to
the last table added to the FROM clause using
Table.naturalRightOuterJoin(String, Object...) |
SelectJoinStep |
naturalRightOuterJoin(TableLike<?> table)
Convenience method to NATURAL RIGHT OUTER JOIN a table to
the last table added to the FROM clause using
Table.naturalRightOuterJoin(TableLike)
Natural joins are supported by most RDBMS. |
SelectOnStep |
rightOuterJoin(String sql)
Convenience method to RIGHT OUTER JOIN a table to the last
table added to the FROM clause using
Table.rightOuterJoin(String)
This is only possible where the underlying RDBMS supports it
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. |
SelectOnStep |
rightOuterJoin(String sql,
Object... bindings)
Convenience method to RIGHT OUTER JOIN a table to the last
table added to the FROM clause using
Table.rightOuterJoin(String, Object...) |
SelectOnStep |
rightOuterJoin(TableLike<?> table)
Convenience method to RIGHT OUTER JOIN a table to the last
table added to the FROM clause using
Table.rightOuterJoin(TableLike)
This is only possible where the underlying RDBMS supports it |
Methods inherited from interface org.jooq.SelectWhereStep |
---|
where, where, where, where, whereExists, whereNotExists |
Methods inherited from interface org.jooq.SelectConnectByStep |
---|
connectBy, connectBy, connectBy, connectByNoCycle, connectByNoCycle, connectByNoCycle |
Methods inherited from interface org.jooq.SelectGroupByStep |
---|
groupBy, groupBy |
Methods inherited from interface org.jooq.SelectHavingStep |
---|
having, having, having, having |
Methods inherited from interface org.jooq.SelectOrderByStep |
---|
orderBy, orderBy, orderBy, orderBy |
Methods inherited from interface org.jooq.SelectLimitStep |
---|
limit, limit, limit, limit, limit, limit |
Methods inherited from interface org.jooq.SelectForUpdateStep |
---|
forShare, forUpdate |
Methods inherited from interface org.jooq.SelectFinalStep |
---|
getQuery |
Methods inherited from interface org.jooq.Select |
---|
except, getSelect, intersect, union, unionAll |
Methods inherited from interface org.jooq.ResultQuery |
---|
bind, bind, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetchAny, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArrays, fetchInto, fetchInto, fetchInto, fetchLater, fetchLater, fetchLazy, fetchLazy, fetchMany, fetchMap, fetchMap, fetchMaps, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOneArray, fetchOneMap, fetchResultSet, getRecordType, getResult |
Methods inherited from interface org.jooq.Query |
---|
execute, getBindValues, getParam, getParams, getSQL, getSQL |
Methods inherited from interface org.jooq.Attachable |
---|
attach |
Methods inherited from interface org.jooq.Adapter |
---|
internalAPI |
Methods inherited from interface org.jooq.TableLike |
---|
asTable, asTable |
Methods inherited from interface org.jooq.FieldLike |
---|
asField, asField |
Methods inherited from interface org.jooq.FieldProvider |
---|
getField, getField, getField, getFields, getIndex |
Method Detail |
---|
SelectOnStep join(TableLike<?> table)
INNER JOIN
a table to the last table
added to the FROM
clause using Table.join(TableLike)
Table.join(TableLike)
SelectOnStep join(String sql)
INNER JOIN
a table to the last table
added to the FROM
clause using Table.join(String)
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Factory.table(String)
,
Table.join(String)
SelectOnStep join(String sql, Object... bindings)
INNER JOIN
a table to the last table
added to the FROM
clause using
Table.join(String, Object...)
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Factory.table(String, Object...)
,
Table.join(String, Object...)
SelectJoinStep crossJoin(TableLike<?> table)
CROSS JOIN
a table to the last table
added to the FROM
clause using
Table.crossJoin(TableLike)
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.crossJoin(TableLike)
SelectJoinStep crossJoin(String sql)
CROSS JOIN
a table to the last table
added to the FROM
clause using
Table.crossJoin(String)
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.crossJoin(String)
SelectJoinStep crossJoin(String sql, Object... bindings)
CROSS JOIN
a table to the last table
added to the FROM
clause using
Table.crossJoin(String, Object...)
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.crossJoin(String, Object...)
SelectOnStep leftOuterJoin(TableLike<?> table)
LEFT OUTER JOIN
a table to the last
table added to the FROM
clause using
Table.leftOuterJoin(TableLike)
Table.leftOuterJoin(TableLike)
SelectOnStep leftOuterJoin(String sql)
LEFT OUTER JOIN
a table to the last
table added to the FROM
clause using
Table.leftOuterJoin(String)
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Factory.table(String)
,
Table.leftOuterJoin(String)
SelectOnStep leftOuterJoin(String sql, Object... bindings)
LEFT OUTER JOIN
a table to the last
table added to the FROM
clause using
Table.leftOuterJoin(String, Object...)
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Factory.table(String, Object...)
,
Table.leftOuterJoin(String, Object...)
SelectOnStep rightOuterJoin(TableLike<?> table)
RIGHT OUTER JOIN
a table to the last
table added to the FROM
clause using
Table.rightOuterJoin(TableLike)
This is only possible where the underlying RDBMS supports it
Table.rightOuterJoin(TableLike)
SelectOnStep rightOuterJoin(String sql)
RIGHT OUTER JOIN
a table to the last
table added to the FROM
clause using
Table.rightOuterJoin(String)
This is only possible where the underlying RDBMS supports it
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Factory.table(String)
,
Table.rightOuterJoin(String)
SelectOnStep rightOuterJoin(String sql, Object... bindings)
RIGHT OUTER JOIN
a table to the last
table added to the FROM
clause using
Table.rightOuterJoin(String, Object...)
This is only possible where the underlying RDBMS supports it
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Factory.table(String, Object...)
,
Table.rightOuterJoin(String, Object...)
SelectOnStep fullOuterJoin(TableLike<?> table)
FULL OUTER JOIN
a table to the last
table added to the FROM
clause using
Table.fullOuterJoin(TableLike)
This is only possible where the underlying RDBMS supports it
Table.fullOuterJoin(TableLike)
SelectOnStep fullOuterJoin(String sql)
FULL OUTER JOIN
a table to the last
table added to the FROM
clause using
Table.fullOuterJoin(String)
This is only possible where the underlying RDBMS supports it
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Factory.table(String)
,
Table.fullOuterJoin(String)
SelectOnStep fullOuterJoin(String sql, Object... bindings)
FULL OUTER JOIN
a tableto the last
table added to the FROM
clause using
Table.fullOuterJoin(String, Object...)
This is only possible where the underlying RDBMS supports it
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Factory.table(String, Object...)
,
Table.fullOuterJoin(String, Object...)
SelectJoinStep naturalJoin(TableLike<?> table)
NATURAL JOIN
a table to the last table
added to the FROM
clause using
Table.naturalJoin(TableLike)
Natural joins are supported by most RDBMS. If they aren't supported, they are simulated if jOOQ has enough information.
Table.naturalJoin(TableLike)
SelectJoinStep naturalJoin(String sql)
NATURAL JOIN
a table to the last table
added to the FROM
clause using
Table.naturalJoin(String)
Natural joins are supported by most RDBMS. If they aren't supported, they are simulated if jOOQ has enough information.
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.naturalJoin(String)
SelectJoinStep naturalJoin(String sql, Object... bindings)
NATURAL JOIN
a table to the last table
added to the FROM
clause using
Table.naturalJoin(String, Object...)
Natural joins are supported by most RDBMS. If they aren't supported, they are simulated if jOOQ has enough information.
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.naturalJoin(String, Object...)
SelectJoinStep naturalLeftOuterJoin(TableLike<?> table)
NATURAL LEFT OUTER JOIN
a table to the
last table added to the FROM
clause using
Table.naturalLeftOuterJoin(TableLike)
Natural joins are supported by most RDBMS. If they aren't supported, they are simulated if jOOQ has enough information.
Table.naturalLeftOuterJoin(TableLike)
SelectJoinStep naturalLeftOuterJoin(String sql)
NATURAL LEFT OUTER JOIN
a table to the
last table added to the FROM
clause using
Table.naturalLeftOuterJoin(String)
Natural joins are supported by most RDBMS. If they aren't supported, they are simulated if jOOQ has enough information.
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.naturalLeftOuterJoin(String)
SelectJoinStep naturalLeftOuterJoin(String sql, Object... bindings)
NATURAL LEFT OUTER JOIN
a table to the
last table added to the FROM
clause using
Table.naturalLeftOuterJoin(String, Object...)
Natural joins are supported by most RDBMS. If they aren't supported, they are simulated if jOOQ has enough information.
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.naturalLeftOuterJoin(String, Object...)
SelectJoinStep naturalRightOuterJoin(TableLike<?> table)
NATURAL RIGHT OUTER JOIN
a table to
the last table added to the FROM
clause using
Table.naturalRightOuterJoin(TableLike)
Natural joins are supported by most RDBMS. If they aren't supported, they are simulated if jOOQ has enough information.
Table.naturalRightOuterJoin(TableLike)
SelectJoinStep naturalRightOuterJoin(String sql)
NATURAL RIGHT OUTER JOIN
a table to
the last table added to the FROM
clause using
Table.naturalRightOuterJoin(String)
Natural joins are supported by most RDBMS. If they aren't supported, they are simulated if jOOQ has enough information.
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.naturalRightOuterJoin(String)
SelectJoinStep naturalRightOuterJoin(String sql, Object... bindings)
NATURAL RIGHT OUTER JOIN
a table to
the last table added to the FROM
clause using
Table.naturalRightOuterJoin(String, Object...)
Natural joins are supported by most RDBMS. If they aren't supported, they are simulated if jOOQ has enough information.
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.naturalRightOuterJoin(String, Object...)
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |