SelectJoinStep (jOOQ 3.8.1 API)

All Superinterfaces:: Attachable, AutoCloseable, FieldLike, Iterable<R>, Query, QueryPart, ResultQuery<R>, Select<R>, SelectConnectByStep<R>, SelectFinalStep<R>, SelectForUpdateStep<R>, SelectGroupByStep<R>, SelectHavingStep<R>, SelectLimitStep<R>, SelectOptionStep<R>, SelectOrderByStep<R>, SelectUnionStep<R>, SelectWhereStep<R>, SelectWindowStep<R>, Serializable, TableLike<R>

All Known Subinterfaces:: SelectOnConditionStep<R>, SelectOptionalOnStep<R>

public interface SelectJoinStep<R extends Record>
extends SelectWhereStep<R>

This type is used for the Select's DSL API when selecting generic Record types.

Example:

 -- 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

Its equivalent in jOOQ

 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();

Refer to the manual for more details

Author:: Lukas Eder

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`SelectJoinStep<R>`	`crossApply(Name name)` `CROSS APPLY` a table to this table.
`SelectJoinStep<R>`	`crossApply(SQL sql)` `CROSS APPLY` a table to this table.
`SelectJoinStep<R>`	`crossApply(String sql)` `CROSS APPLY` a table to this table.
`SelectJoinStep<R>`	`crossApply(String sql, Object... bindings)` `CROSS APPLY` a table to this table.
`SelectJoinStep<R>`	`crossApply(String sql, QueryPart... parts)` `CROSS APPLY` a table to this table.
`SelectJoinStep<R>`	`crossApply(TableLike<?> table)` `CROSS APPLY` a table to this table.
`SelectJoinStep<R>`	`crossJoin(Name name)` Convenience method to `CROSS JOIN` a table to the last table added to the `FROM` clause using `Table.crossJoin(Name)` If this syntax is unavailable, it is emulated with a regular `INNER JOIN`.
`SelectJoinStep<R>`	`crossJoin(SQL 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 emulated with a regular `INNER JOIN`.
`SelectJoinStep<R>`	`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 emulated with a regular `INNER JOIN`.
`SelectJoinStep<R>`	`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<R>`	`crossJoin(String sql, QueryPart... parts)` Convenience method to `CROSS JOIN` a table to the last table added to the `FROM` clause using `Table.crossJoin(String, QueryPart...)`
`SelectJoinStep<R>`	`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 emulated with a regular `INNER JOIN`.
`SelectOnStep<R>`	`fullOuterJoin(Name name)` Convenience method to `FULL OUTER JOIN` a tableto the last table added to the `FROM` clause using `Table.fullOuterJoin(Name)` This is only possible where the underlying RDBMS supports it
`SelectOnStep<R>`	`fullOuterJoin(SQL 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<R>`	`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<R>`	`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<R>`	`fullOuterJoin(String sql, QueryPart... parts)` Convenience method to `FULL OUTER JOIN` a tableto the last table added to the `FROM` clause using `Table.fullOuterJoin(String, QueryPart...)`
`SelectOnStep<R>`	`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<R>`	`innerJoin(Name name)` Convenience method to `INNER JOIN` a table to the last table added to the `FROM` clause using `Table.join(Name)`.
`SelectOnStep<R>`	`innerJoin(SQL sql)` Convenience method to `INNER JOIN` a table to the last table added to the `FROM` clause using `Table.join(String)`.
`SelectOnStep<R>`	`innerJoin(String sql)` Convenience method to `INNER JOIN` a table to the last table added to the `FROM` clause using `Table.join(String)`.
`SelectOnStep<R>`	`innerJoin(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<R>`	`innerJoin(String sql, QueryPart... parts)` Convenience method to `INNER JOIN` a table to the last table added to the `FROM` clause using `Table.join(String, QueryPart...)`.
`SelectOnStep<R>`	`innerJoin(TableLike<?> table)` Convenience method to `INNER JOIN` a table to the last table added to the `FROM` clause using `Table.join(TableLike)`.
`SelectOnStep<R>`	`join(Name name)` Convenience method to `INNER JOIN` a table to the last table added to the `FROM` clause using `Table.join(Name)`.
`SelectOnStep<R>`	`join(SQL sql)` Convenience method to `INNER JOIN` a table to the last table added to the `FROM` clause using `Table.join(String)`.
`SelectOnStep<R>`	`join(String sql)` Convenience method to `INNER JOIN` a table to the last table added to the `FROM` clause using `Table.join(String)`.
`SelectOnStep<R>`	`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<R>`	`join(String sql, QueryPart... parts)` Convenience method to `INNER JOIN` a table to the last table added to the `FROM` clause using `Table.join(String, QueryPart...)`.
`SelectOnStep<R>`	`join(TableLike<?> table)` Convenience method to `INNER JOIN` a table to the last table added to the `FROM` clause using `Table.join(TableLike)`.
`SelectOptionalOnStep<R>`	`join(TableLike<?> table, JoinType type)` Convenience method to join a table to the last table added to the `FROM` clause using `Table.join(TableLike, JoinType)` Depending on the `JoinType`, a subsequent `SelectOnStep.on(Condition...)` or `SelectOnStep.using(Field...)` clause is required.
`SelectOnStep<R>`	`leftAntiJoin(TableLike<?> table)` A synthetic `LEFT ANTI JOIN` clause that translates to an equivalent `NOT EXISTS` predicate.
`SelectJoinPartitionByStep<R>`	`leftJoin(Name name)` Convenience method to `LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.leftOuterJoin(Name)`.
`SelectJoinPartitionByStep<R>`	`leftJoin(SQL sql)` Convenience method to `LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.leftOuterJoin(String)`.
`SelectJoinPartitionByStep<R>`	`leftJoin(String sql)` Convenience method to `LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.leftOuterJoin(String)`.
`SelectJoinPartitionByStep<R>`	`leftJoin(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...)`.
`SelectJoinPartitionByStep<R>`	`leftJoin(String sql, QueryPart... parts)` Convenience method to `LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.leftOuterJoin(String, QueryPart...)`.
`SelectJoinPartitionByStep<R>`	`leftJoin(TableLike<?> table)` Convenience method to `LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.leftOuterJoin(TableLike)`.
`SelectJoinPartitionByStep<R>`	`leftOuterJoin(Name name)` Convenience method to `LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.leftOuterJoin(Name)`
`SelectJoinPartitionByStep<R>`	`leftOuterJoin(SQL 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.
`SelectJoinPartitionByStep<R>`	`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.
`SelectJoinPartitionByStep<R>`	`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...)`
`SelectJoinPartitionByStep<R>`	`leftOuterJoin(String sql, QueryPart... parts)` Convenience method to `LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.leftOuterJoin(String, QueryPart...)`
`SelectJoinPartitionByStep<R>`	`leftOuterJoin(TableLike<?> table)` Convenience method to `LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.leftOuterJoin(TableLike)`
`SelectOnStep<R>`	`leftSemiJoin(TableLike<?> table)` A synthetic `LEFT SEMI JOIN` clause that translates to an equivalent `EXISTS` predicate.
`SelectJoinStep<R>`	`naturalJoin(Name name)` Convenience method to `NATURAL JOIN` a table to the last table added to the `FROM` clause using `Table.naturalJoin(Name)` Natural joins are supported by most RDBMS.
`SelectJoinStep<R>`	`naturalJoin(SQL 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<R>`	`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<R>`	`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<R>`	`naturalJoin(String sql, QueryPart... parts)` Convenience method to `NATURAL JOIN` a table to the last table added to the `FROM` clause using `Table.naturalJoin(String, QueryPart...)`
`SelectJoinStep<R>`	`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<R>`	`naturalLeftOuterJoin(Name name)` Convenience method to `NATURAL LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalLeftOuterJoin(Name)` Natural joins are supported by most RDBMS.
`SelectJoinStep<R>`	`naturalLeftOuterJoin(SQL 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<R>`	`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<R>`	`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<R>`	`naturalLeftOuterJoin(String sql, QueryPart... parts)` Convenience method to `NATURAL LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalLeftOuterJoin(String, QueryPart...)`
`SelectJoinStep<R>`	`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<R>`	`naturalRightOuterJoin(Name name)` Convenience method to `NATURAL RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalRightOuterJoin(Name)` Natural joins are supported by most RDBMS.
`SelectJoinStep<R>`	`naturalRightOuterJoin(SQL 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<R>`	`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<R>`	`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<R>`	`naturalRightOuterJoin(String sql, QueryPart... parts)` Convenience method to `NATURAL RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalRightOuterJoin(String, QueryPart...)`
`SelectJoinStep<R>`	`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.
`SelectJoinStep<R>`	`outerApply(Name name)` `OUTER APPLY` a table to this table.
`SelectJoinStep<R>`	`outerApply(SQL sql)` `OUTER APPLY` a table to this table.
`SelectJoinStep<R>`	`outerApply(String sql)` `OUTER APPLY` a table to this table.
`SelectJoinStep<R>`	`outerApply(String sql, Object... bindings)` `OUTER APPLY` a table to this table.
`SelectJoinStep<R>`	`outerApply(String sql, QueryPart... parts)` `OUTER APPLY` a table to this table.
`SelectJoinStep<R>`	`outerApply(TableLike<?> table)` `OUTER APPLY` a table to this table.
`SelectJoinPartitionByStep<R>`	`rightJoin(Name name)` Convenience method to `RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.rightOuterJoin(Name)`.
`SelectJoinPartitionByStep<R>`	`rightJoin(SQL sql)` Convenience method to `RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.rightOuterJoin(String)`.
`SelectJoinPartitionByStep<R>`	`rightJoin(String sql)` Convenience method to `RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.rightOuterJoin(String)`.
`SelectJoinPartitionByStep<R>`	`rightJoin(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...)`.
`SelectJoinPartitionByStep<R>`	`rightJoin(String sql, QueryPart... parts)` Convenience method to `RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.rightOuterJoin(String, QueryPart...)`.
`SelectJoinPartitionByStep<R>`	`rightJoin(TableLike<?> table)` Convenience method to `RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.rightOuterJoin(TableLike)`.
`SelectJoinPartitionByStep<R>`	`rightOuterJoin(Name name)` Convenience method to `RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.rightOuterJoin(Name)` This is only possible where the underlying RDBMS supports it
`SelectJoinPartitionByStep<R>`	`rightOuterJoin(SQL 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.
`SelectJoinPartitionByStep<R>`	`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.
`SelectJoinPartitionByStep<R>`	`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...)`
`SelectJoinPartitionByStep<R>`	`rightOuterJoin(String sql, QueryPart... parts)` Convenience method to `RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.rightOuterJoin(String, QueryPart...)`
`SelectJoinPartitionByStep<R>`	`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
`SelectOnStep<R>`	`straightJoin(Name name)` `STRAIGHT_JOIN` a table to this table.
`SelectOnStep<R>`	`straightJoin(SQL sql)` `STRAIGHT_JOIN` a table to this table.
`SelectOnStep<R>`	`straightJoin(String sql)` `STRAIGHT_JOIN` a table to this table.
`SelectOnStep<R>`	`straightJoin(String sql, Object... bindings)` `STRAIGHT_JOIN` a table to this table.
`SelectOnStep<R>`	`straightJoin(String sql, QueryPart... parts)` `STRAIGHT_JOIN` a table to this table.
`SelectOnStep<R>`	`straightJoin(TableLike<?> table)` `STRAIGHT_JOIN` a table to this table.

Methods inherited from interface org.jooq.SelectWhereStep
where, where, where, where, where, where, where, where, whereExists, whereNotExists

Methods inherited from interface org.jooq.SelectConnectByStep
connectBy, connectBy, connectBy, connectBy, connectBy, connectBy, connectBy, connectByNoCycle, connectByNoCycle, connectByNoCycle, connectByNoCycle, connectByNoCycle, connectByNoCycle, connectByNoCycle

Methods inherited from interface org.jooq.SelectGroupByStep
groupBy, groupBy

Methods inherited from interface org.jooq.SelectHavingStep
having, having, having, having, having, having, having, having

Methods inherited from interface org.jooq.SelectWindowStep
window, window

Methods inherited from interface org.jooq.SelectOrderByStep
orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderBy, orderSiblingsBy, orderSiblingsBy, orderSiblingsBy, orderSiblingsBy

Methods inherited from interface org.jooq.SelectLimitStep
limit, limit, limit, limit, limit, limit, offset, offset

Methods inherited from interface org.jooq.SelectForUpdateStep
forShare, forUpdate, withCheckOption, withReadOnly

Methods inherited from interface org.jooq.SelectOptionStep
option

Methods inherited from interface org.jooq.SelectUnionStep
except, exceptAll, intersect, intersectAll, union, unionAll

Methods inherited from interface org.jooq.SelectFinalStep
getQuery

Methods inherited from interface org.jooq.Select
fetchCount, getSelect

Methods inherited from interface org.jooq.ResultQuery
bind, bind, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAny, fetchAnyArray, fetchAnyInto, fetchAnyInto, fetchAnyMap, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArrays, fetchAsync, fetchAsync, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchInto, fetchInto, fetchInto, fetchLater, fetchLater, fetchLazy, fetchLazy, fetchMany, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMaps, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOneArray, fetchOneInto, fetchOneInto, fetchOneMap, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptional, fetchOptionalArray, fetchOptionalInto, fetchOptionalInto, fetchOptionalMap, fetchResultSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSet, fetchSize, fetchStream, getRecordType, getResult, intern, intern, intern, intern, iterator, keepStatement, maxRows, queryTimeout, resultSetConcurrency, resultSetHoldability, resultSetType, stream

Methods inherited from interface org.jooq.Query
cancel, close, execute, executeAsync, executeAsync, getBindValues, getParam, getParams, getSQL, getSQL, getSQL, isExecutable

Methods inherited from interface org.jooq.QueryPart
equals, hashCode, toString

Methods inherited from interface org.jooq.Attachable
attach, detach

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface org.jooq.TableLike
asTable, asTable, asTable, field, field, field, field, field, field, field, field, field, field, fields, fields, fields, fields, fields, fieldsRow

Methods inherited from interface org.jooq.FieldLike
asField, asField

- Method Detail
  - join
```
@Support
SelectOptionalOnStep<R> join(TableLike<?> table,
                                       JoinType type)
```
    Convenience method to join a table to the last table added to the FROM clause using Table.join(TableLike, JoinType)
    Depending on the JoinType, a subsequent SelectOnStep.on(Condition...) or SelectOnStep.using(Field...) clause is required. If it is required but omitted, the JOIN clause will be ignored
  - join
```
@Support
SelectOnStep<R> join(TableLike<?> table)
```
    Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(TableLike).
    A synonym for innerJoin(TableLike).
    
    See Also:
    
    Table.join(TableLike), innerJoin(TableLike)
  - join
```
@Support
 @PlainSQL
SelectOnStep<R> join(SQL sql)
```
    Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(String).
    A synonym for innerJoin(String).
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(SQL), Table.join(SQL), innerJoin(SQL), SQL
  - join
```
@Support
 @PlainSQL
SelectOnStep<R> join(String sql)
```
    Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(String).
    A synonym for innerJoin(String).
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String), Table.join(String), innerJoin(String), SQL
  - join
```
@Support
 @PlainSQL
SelectOnStep<R> 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...).
    A synonym for innerJoin(String, Object...).
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, Object...), Table.join(String, Object...), innerJoin(String, Object...), SQL
  - join
```
@Support
 @PlainSQL
SelectOnStep<R> join(String sql,
                                           QueryPart... parts)
```
    Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(String, QueryPart...).
    A synonym for innerJoin(String, QueryPart...).
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.join(String, QueryPart...), innerJoin(String, QueryPart...), SQL
  - join
```
@Support
 @PlainSQL
SelectOnStep<R> join(Name name)
```
    Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(Name).
    A synonym for innerJoin(Name).
    
    See Also:
    
    DSL.table(Name), Table.join(Name), innerJoin(Name)
  - innerJoin
```
@Support
SelectOnStep<R> innerJoin(TableLike<?> table)
```
    Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(TableLike).
    
    See Also:
    
    Table.innerJoin(TableLike)
  - innerJoin
```
@Support
 @PlainSQL
SelectOnStep<R> innerJoin(SQL 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. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(SQL), Table.innerJoin(SQL), SQL
  - innerJoin
```
@Support
 @PlainSQL
SelectOnStep<R> innerJoin(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. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String), Table.innerJoin(String), SQL
  - innerJoin
```
@Support
 @PlainSQL
SelectOnStep<R> innerJoin(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...).
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, Object...), Table.innerJoin(String, Object...), SQL
  - innerJoin
```
@Support
 @PlainSQL
SelectOnStep<R> innerJoin(String sql,
                                                QueryPart... parts)
```
    Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(String, QueryPart...).
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.innerJoin(String, QueryPart...), SQL
  - innerJoin
```
@Support
SelectOnStep<R> innerJoin(Name name)
```
    Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(Name).
    
    See Also:
    
    DSL.table(Name), Table.innerJoin(Name)
  - crossJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,VERTICA})
SelectJoinStep<R> 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 emulated with a regular INNER JOIN. The following two constructs are equivalent:
```
 A cross join B
 A join B on 1 = 1
 
```
    See Also:
    
    Table.crossJoin(TableLike)
  - crossJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinStep<R> crossJoin(SQL 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 emulated with a regular INNER JOIN. The following two constructs are equivalent:
```
 A cross join B
 A join B on 1 = 1
 
```
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    See Also:
    
    DSL.table(SQL), Table.crossJoin(SQL), SQL
  - crossJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinStep<R> 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 emulated with a regular INNER JOIN. The following two constructs are equivalent:
```
 A cross join B
 A join B on 1 = 1
 
```
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    See Also:
    
    DSL.table(String), Table.crossJoin(String), SQL
  - crossJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinStep<R> 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...)
    If this syntax is unavailable, it is emulated with a regular INNER JOIN. The following two constructs are equivalent:
```
 A cross join B
 A join B on 1 = 1
 
```
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    See Also:
    
    DSL.table(String, Object...), Table.crossJoin(String, Object...), SQL
  - crossJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinStep<R> crossJoin(String sql,
                                                                                                                                                                                      QueryPart... parts)
```
    Convenience method to CROSS JOIN a table to the last table added to the FROM clause using Table.crossJoin(String, QueryPart...)
    If this syntax is unavailable, it is emulated with a regular INNER JOIN. The following two constructs are equivalent:
```
 A cross join B
 A join B on 1 = 1
 
```
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    See Also:
    
    DSL.table(String, QueryPart...), Table.crossJoin(String, QueryPart...), SQL
  - crossJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,VERTICA})
SelectJoinStep<R> crossJoin(Name name)
```
    Convenience method to CROSS JOIN a table to the last table added to the FROM clause using Table.crossJoin(Name)
    If this syntax is unavailable, it is emulated with a regular INNER JOIN. The following two constructs are equivalent:
```
 A cross join B
 A join B on 1 = 1
 
```
    See Also:
    
    DSL.table(Name), Table.crossJoin(Name)
  - leftJoin
```
@Support
SelectJoinPartitionByStep<R> leftJoin(TableLike<?> table)
```
    Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(TableLike).
    A synonym for leftOuterJoin(TableLike).
    
    See Also:
    
    Table.leftOuterJoin(TableLike), leftOuterJoin(TableLike)
  - leftJoin
```
@Support
 @PlainSQL
SelectJoinPartitionByStep<R> leftJoin(SQL sql)
```
    Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(String).
    A synonym for leftOuterJoin(String).
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(SQL), Table.leftOuterJoin(SQL), leftOuterJoin(SQL), SQL
  - leftJoin
```
@Support
 @PlainSQL
SelectJoinPartitionByStep<R> leftJoin(String sql)
```
    Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(String).
    A synonym for leftOuterJoin(String).
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String), Table.leftOuterJoin(String), leftOuterJoin(String), SQL
  - leftJoin
```
@Support
 @PlainSQL
SelectJoinPartitionByStep<R> leftJoin(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...).
    A synonym for leftOuterJoin(String, Object...).
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, Object...), Table.leftOuterJoin(String, Object...), leftOuterJoin(String, Object...), SQL
  - leftJoin
```
@Support
 @PlainSQL
SelectJoinPartitionByStep<R> leftJoin(String sql,
                                                            QueryPart... parts)
```
    Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(String, QueryPart...).
    A synonym for leftOuterJoin(String, QueryPart...).
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.leftOuterJoin(String, QueryPart...), leftOuterJoin(String, QueryPart...), SQL
  - leftJoin
```
@Support
SelectJoinPartitionByStep<R> leftJoin(Name name)
```
    Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(Name).
    A synonym for leftOuterJoin(Name).
    
    See Also:
    
    DSL.table(Name), Table.leftOuterJoin(Name), leftOuterJoin(Name)
  - leftOuterJoin
```
@Support
SelectJoinPartitionByStep<R> leftOuterJoin(TableLike<?> table)
```
    Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(TableLike)
    
    See Also:
    
    Table.leftOuterJoin(TableLike)
  - leftOuterJoin
```
@Support
 @PlainSQL
SelectJoinPartitionByStep<R> leftOuterJoin(SQL 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. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(SQL), Table.leftOuterJoin(SQL), SQL
  - leftOuterJoin
```
@Support
 @PlainSQL
SelectJoinPartitionByStep<R> 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. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String), Table.leftOuterJoin(String), SQL
  - leftOuterJoin
```
@Support
 @PlainSQL
SelectJoinPartitionByStep<R> 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...)
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, Object...), Table.leftOuterJoin(String, Object...), SQL
  - leftOuterJoin
```
@Support
 @PlainSQL
SelectJoinPartitionByStep<R> leftOuterJoin(String sql,
                                                                 QueryPart... parts)
```
    Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(String, QueryPart...)
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.leftOuterJoin(String, QueryPart...), SQL
  - leftOuterJoin
```
@Support
SelectJoinPartitionByStep<R> leftOuterJoin(Name name)
```
    Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(Name)
    
    See Also:
    
    DSL.table(Name), Table.leftOuterJoin(Name)
  - rightJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
SelectJoinPartitionByStep<R> rightJoin(TableLike<?> table)
```
    Convenience method to RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.rightOuterJoin(TableLike).
    A synonym for rightOuterJoin(TableLike).
    This is only possible where the underlying RDBMS supports it
    
    See Also:
    
    Table.rightOuterJoin(TableLike), rightOuterJoin(TableLike)
  - rightJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinPartitionByStep<R> rightJoin(SQL sql)
```
    Convenience method to RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.rightOuterJoin(String).
    A synonym for rightOuterJoin(String).
    This is only possible where the underlying RDBMS supports it
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(SQL), Table.rightOuterJoin(SQL), rightOuterJoin(SQL), SQL
  - rightJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinPartitionByStep<R> rightJoin(String sql)
```
    Convenience method to RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.rightOuterJoin(String).
    A synonym for rightOuterJoin(String).
    This is only possible where the underlying RDBMS supports it
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String), Table.rightOuterJoin(String), rightOuterJoin(String), SQL
  - rightJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinPartitionByStep<R> rightJoin(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...).
    A synonym for rightOuterJoin(String, Object...).
    This is only possible where the underlying RDBMS supports it
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, Object...), Table.rightOuterJoin(String, Object...), rightOuterJoin(String, Object...), SQL
  - rightJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinPartitionByStep<R> rightJoin(String sql,
                                                                                                                                                                                                 QueryPart... parts)
```
    Convenience method to RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.rightOuterJoin(String, QueryPart...).
    A synonym for rightOuterJoin(String, QueryPart...).
    This is only possible where the underlying RDBMS supports it
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.rightOuterJoin(String, QueryPart...), rightOuterJoin(String, QueryPart...), SQL
  - rightJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
SelectJoinPartitionByStep<R> rightJoin(Name name)
```
    Convenience method to RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.rightOuterJoin(Name).
    A synonym for rightOuterJoin(Name).
    This is only possible where the underlying RDBMS supports it
    
    See Also:
    
    DSL.table(Name), Table.rightOuterJoin(Name), rightOuterJoin(Name)
  - rightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
SelectJoinPartitionByStep<R> 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
    
    See Also:
    
    Table.rightOuterJoin(TableLike)
  - rightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinPartitionByStep<R> rightOuterJoin(SQL 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. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(SQL), Table.rightOuterJoin(SQL), SQL
  - rightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinPartitionByStep<R> 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. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String), Table.rightOuterJoin(String), SQL
  - rightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinPartitionByStep<R> 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...)
    This is only possible where the underlying RDBMS supports it
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, Object...), Table.rightOuterJoin(String, Object...), SQL
  - rightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinPartitionByStep<R> rightOuterJoin(String sql,
                                                                                                                                                                                                      QueryPart... parts)
```
    Convenience method to RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.rightOuterJoin(String, QueryPart...)
    This is only possible where the underlying RDBMS supports it
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.rightOuterJoin(String, QueryPart...), SQL
  - rightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
SelectJoinPartitionByStep<R> rightOuterJoin(Name name)
```
    Convenience method to RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.rightOuterJoin(Name)
    This is only possible where the underlying RDBMS supports it
    
    See Also:
    
    DSL.table(Name), Table.rightOuterJoin(Name)
  - fullOuterJoin
```
@Support(value={DB2,FIREBIRD,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
SelectOnStep<R> 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
    
    See Also:
    
    Table.fullOuterJoin(TableLike)
  - fullOuterJoin
```
@Support(value={DB2,FIREBIRD,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectOnStep<R> fullOuterJoin(SQL 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. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(SQL), Table.fullOuterJoin(SQL), SQL
  - fullOuterJoin
```
@Support(value={DB2,FIREBIRD,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectOnStep<R> 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. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String), Table.fullOuterJoin(String), SQL
  - fullOuterJoin
```
@Support(value={DB2,FIREBIRD,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectOnStep<R> 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...)
    This is only possible where the underlying RDBMS supports it
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, Object...), Table.fullOuterJoin(String, Object...), SQL
  - fullOuterJoin
```
@Support(value={DB2,FIREBIRD,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectOnStep<R> fullOuterJoin(String sql,
                                                                                                                                               QueryPart... parts)
```
    Convenience method to FULL OUTER JOIN a tableto the last table added to the FROM clause using Table.fullOuterJoin(String, QueryPart...)
    This is only possible where the underlying RDBMS supports it
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.fullOuterJoin(String, QueryPart...), SQL
  - fullOuterJoin
```
@Support(value={DB2,FIREBIRD,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
SelectOnStep<R> fullOuterJoin(Name name)
```
    Convenience method to FULL OUTER JOIN a tableto the last table added to the FROM clause using Table.fullOuterJoin(Name)
    This is only possible where the underlying RDBMS supports it
    
    See Also:
    
    DSL.table(Name), Table.fullOuterJoin(Name)
  - naturalJoin
```
@Support
SelectJoinStep<R> 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. If they aren't supported, they are emulated if jOOQ has enough information.
    
    See Also:
    
    Table.naturalJoin(TableLike)
  - naturalJoin
```
@Support
 @PlainSQL
SelectJoinStep<R> naturalJoin(SQL 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. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(SQL), Table.naturalJoin(SQL), SQL
  - naturalJoin
```
@Support
 @PlainSQL
SelectJoinStep<R> 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. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(String), Table.naturalJoin(String), SQL
  - naturalJoin
```
@Support
 @PlainSQL
SelectJoinStep<R> 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...)
    Natural joins are supported by most RDBMS. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(String, Object...), Table.naturalJoin(String, Object...), SQL
  - naturalJoin
```
@Support
 @PlainSQL
SelectJoinStep<R> naturalJoin(String sql,
                                                    QueryPart... parts)
```
    Convenience method to NATURAL JOIN a table to the last table added to the FROM clause using Table.naturalJoin(String, QueryPart...)
    Natural joins are supported by most RDBMS. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.naturalJoin(String, QueryPart...), SQL
  - naturalJoin
```
@Support
SelectJoinStep<R> naturalJoin(Name name)
```
    Convenience method to NATURAL JOIN a table to the last table added to the FROM clause using Table.naturalJoin(Name)
    Natural joins are supported by most RDBMS. If they aren't supported, they are emulated if jOOQ has enough information.
    
    See Also:
    
    DSL.table(Name), Table.naturalJoin(Name)
  - naturalLeftOuterJoin
```
@Support
SelectJoinStep<R> 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. If they aren't supported, they are emulated if jOOQ has enough information.
    
    See Also:
    
    Table.naturalLeftOuterJoin(TableLike)
  - naturalLeftOuterJoin
```
@Support
 @PlainSQL
SelectJoinStep<R> naturalLeftOuterJoin(SQL 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. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(SQL), Table.naturalLeftOuterJoin(SQL), SQL
  - naturalLeftOuterJoin
```
@Support
 @PlainSQL
SelectJoinStep<R> 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. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(String), Table.naturalLeftOuterJoin(String), SQL
  - naturalLeftOuterJoin
```
@Support
 @PlainSQL
SelectJoinStep<R> 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...)
    Natural joins are supported by most RDBMS. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(String, Object...), Table.naturalLeftOuterJoin(String, Object...), SQL
  - naturalLeftOuterJoin
```
@Support
 @PlainSQL
SelectJoinStep<R> naturalLeftOuterJoin(String sql,
                                                             QueryPart... parts)
```
    Convenience method to NATURAL LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.naturalLeftOuterJoin(String, QueryPart...)
    Natural joins are supported by most RDBMS. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.naturalLeftOuterJoin(String, QueryPart...), SQL
  - naturalLeftOuterJoin
```
@Support
SelectJoinStep<R> naturalLeftOuterJoin(Name name)
```
    Convenience method to NATURAL LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.naturalLeftOuterJoin(Name)
    Natural joins are supported by most RDBMS. If they aren't supported, they are emulated if jOOQ has enough information.
    
    See Also:
    
    DSL.table(Name), Table.naturalLeftOuterJoin(Name)
  - naturalRightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
SelectJoinStep<R> 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. If they aren't supported, they are emulated if jOOQ has enough information.
    
    See Also:
    
    Table.naturalRightOuterJoin(TableLike)
  - naturalRightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinStep<R> naturalRightOuterJoin(SQL 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. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(SQL), Table.naturalRightOuterJoin(SQL), SQL
  - naturalRightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinStep<R> 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. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(String), Table.naturalRightOuterJoin(String), SQL
  - naturalRightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinStep<R> 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...)
    Natural joins are supported by most RDBMS. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(String, Object...), Table.naturalRightOuterJoin(String, Object...), SQL
  - naturalRightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
 @PlainSQL
SelectJoinStep<R> naturalRightOuterJoin(String sql,
                                                                                                                                                                                             QueryPart... parts)
```
    Convenience method to NATURAL RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.naturalRightOuterJoin(String, QueryPart...)
    Natural joins are supported by most RDBMS. If they aren't supported, they are emulated 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!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.naturalRightOuterJoin(String, QueryPart...), SQL
  - naturalRightOuterJoin
```
@Support(value={ACCESS,ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,VERTICA})
SelectJoinStep<R> naturalRightOuterJoin(Name name)
```
    Convenience method to NATURAL RIGHT OUTER JOIN a table to the last table added to the FROM clause using Table.naturalRightOuterJoin(Name)
    Natural joins are supported by most RDBMS. If they aren't supported, they are emulated if jOOQ has enough information.
    
    See Also:
    
    DSL.table(Name), Table.naturalRightOuterJoin(Name)
  - leftSemiJoin
```
@Support
SelectOnStep<R> leftSemiJoin(TableLike<?> table)
```
    A synthetic LEFT SEMI JOIN clause that translates to an equivalent EXISTS predicate.
    The following two SQL snippets are semantically equivalent:
```
 -- Using LEFT SEMI JOIN
 FROM A
     LEFT SEMI JOIN B
         ON A.ID = B.ID

 -- Using WHERE EXISTS
 FROM A
 WHERE EXISTS (
     SELECT 1 FROM B WHERE A.ID = B.ID
 )
 
```
    See Also:
    
    Table.leftSemiJoin(TableLike)
  - leftAntiJoin
```
@Support
SelectOnStep<R> leftAntiJoin(TableLike<?> table)
```
    A synthetic LEFT ANTI JOIN clause that translates to an equivalent NOT EXISTS predicate.
    The following two SQL snippets are semantically equivalent:
```
 -- Using LEFT ANTI JOIN
 FROM A
     LEFT ANTI JOIN B
         ON A.ID = B.ID

 -- Using WHERE NOT EXISTS
 FROM A
 WHERE NOT EXISTS (
     SELECT 1 FROM B WHERE A.ID = B.ID
 )
 
```
    See Also:
    
    Table.leftAntiJoin(TableLike)
  - crossApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
SelectJoinStep<R> crossApply(TableLike<?> table)
```
    CROSS APPLY a table to this table.
    
    See Also:
    
    Table.crossApply(TableLike)
  - crossApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
 @PlainSQL
SelectJoinStep<R> crossApply(SQL sql)
```
    CROSS APPLY a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(SQL), Table.crossApply(SQL), SQL
  - crossApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
 @PlainSQL
SelectJoinStep<R> crossApply(String sql)
```
    CROSS APPLY a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String), Table.crossApply(String), SQL
  - crossApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
 @PlainSQL
SelectJoinStep<R> crossApply(String sql,
                                                                                                    Object... bindings)
```
    CROSS APPLY a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, Object...), Table.crossApply(String, Object...), SQL
  - crossApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
 @PlainSQL
SelectJoinStep<R> crossApply(String sql,
                                                                                                    QueryPart... parts)
```
    CROSS APPLY a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.crossApply(String, QueryPart...), SQL
  - crossApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
SelectJoinStep<R> crossApply(Name name)
```
    CROSS APPLY a table to this table.
    
    See Also:
    
    DSL.table(Name), Table.crossApply(Name)
  - outerApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
SelectJoinStep<R> outerApply(TableLike<?> table)
```
    OUTER APPLY a table to this table.
    
    See Also:
    
    Table.outerApply(TableLike)
  - outerApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
 @PlainSQL
SelectJoinStep<R> outerApply(SQL sql)
```
    OUTER APPLY a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(SQL), Table.outerApply(SQL), SQL
  - outerApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
 @PlainSQL
SelectJoinStep<R> outerApply(String sql)
```
    OUTER APPLY a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String), Table.outerApply(String), SQL
  - outerApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
 @PlainSQL
SelectJoinStep<R> outerApply(String sql,
                                                                                                    Object... bindings)
```
    OUTER APPLY a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, Object...), Table.outerApply(String, Object...), SQL
  - outerApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
 @PlainSQL
SelectJoinStep<R> outerApply(String sql,
                                                                                                    QueryPart... parts)
```
    OUTER APPLY a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.outerApply(String, QueryPart...), SQL
  - outerApply
```
@Support(value={ORACLE12C,POSTGRES_9_3,SQLSERVER,SYBASE})
SelectJoinStep<R> outerApply(Name name)
```
    OUTER APPLY a table to this table.
    
    See Also:
    
    DSL.table(Name), Table.outerApply(Name)
  - straightJoin
```
@Support(value=MYSQL)
SelectOnStep<R> straightJoin(TableLike<?> table)
```
    STRAIGHT_JOIN a table to this table.
    
    See Also:
    
    Table.straightJoin(TableLike)
  - straightJoin
```
@Support(value=MYSQL)
 @PlainSQL
SelectOnStep<R> straightJoin(SQL sql)
```
    STRAIGHT_JOIN a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(SQL), Table.straightJoin(SQL)
  - straightJoin
```
@Support(value=MYSQL)
 @PlainSQL
SelectOnStep<R> straightJoin(String sql)
```
    STRAIGHT_JOIN a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String), Table.straightJoin(String)
  - straightJoin
```
@Support(value=MYSQL)
 @PlainSQL
SelectOnStep<R> straightJoin(String sql,
                                                                Object... bindings)
```
    STRAIGHT_JOIN a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, Object...), Table.straightJoin(String, Object...)
  - straightJoin
```
@Support(value=MYSQL)
 @PlainSQL
SelectOnStep<R> straightJoin(String sql,
                                                                QueryPart... parts)
```
    STRAIGHT_JOIN a table to this table.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    
    DSL.table(String, QueryPart...), Table.straightJoin(String, QueryPart...)
  - straightJoin
```
@Support(value=MYSQL)
SelectOnStep<R> straightJoin(Name name)
```
    STRAIGHT_JOIN a table to this table.
    
    See Also:
    
    DSL.table(Name), Table.straightJoin(Name)

Interface SelectJoinStep<R extends Record>

Method Summary

Methods inherited from interface org.jooq.SelectWhereStep

Methods inherited from interface org.jooq.SelectConnectByStep

Methods inherited from interface org.jooq.SelectGroupByStep

Methods inherited from interface org.jooq.SelectHavingStep

Methods inherited from interface org.jooq.SelectWindowStep

Methods inherited from interface org.jooq.SelectOrderByStep

Methods inherited from interface org.jooq.SelectLimitStep

Methods inherited from interface org.jooq.SelectForUpdateStep

Methods inherited from interface org.jooq.SelectOptionStep

Methods inherited from interface org.jooq.SelectUnionStep

Methods inherited from interface org.jooq.SelectFinalStep

Methods inherited from interface org.jooq.Select

Methods inherited from interface org.jooq.ResultQuery

Methods inherited from interface org.jooq.Query

Methods inherited from interface org.jooq.QueryPart

Methods inherited from interface org.jooq.Attachable

Methods inherited from interface java.lang.Iterable

Methods inherited from interface org.jooq.TableLike

Methods inherited from interface org.jooq.FieldLike

Method Detail

join

join

join

join

join

join

join

innerJoin

innerJoin

innerJoin

innerJoin

innerJoin

innerJoin

crossJoin

crossJoin

crossJoin

crossJoin

crossJoin

crossJoin

leftJoin

leftJoin

leftJoin

leftJoin

leftJoin

leftJoin

leftOuterJoin

leftOuterJoin

leftOuterJoin

leftOuterJoin

leftOuterJoin

leftOuterJoin

rightJoin

rightJoin

rightJoin

rightJoin

rightJoin

rightJoin

rightOuterJoin

rightOuterJoin

rightOuterJoin

rightOuterJoin

rightOuterJoin

rightOuterJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

naturalJoin

naturalJoin

naturalJoin

naturalJoin

naturalJoin

naturalJoin

naturalLeftOuterJoin

naturalLeftOuterJoin

naturalLeftOuterJoin