SelectJoinStep (jOOQ 3.14.2 API)

All Superinterfaces:

Attachable, AutoCloseable, FieldLike, Iterable<R>, org.reactivestreams.Publisher<R>, Query, QueryPart, ResultQuery<R>, Select<R>, SelectConnectByStep<R>, SelectCorrelatedSubqueryStep<R>, SelectFinalStep<R>, SelectForStep<R>, SelectForUpdateStep<R>, SelectGroupByStep<R>, SelectHavingStep<R>, SelectLimitStep<R>, SelectOptionStep<R>, SelectOrderByStep<R>, SelectQualifyStep<R>, SelectUnionStep<R>, SelectWhereStep<R>, SelectWindowStep<R>, Serializable, Statement, 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

Referencing XYZ*Step types directly from client code

It is usually not recommended to reference any XYZ*Step types directly from client code, or assign them to local variables. When writing dynamic SQL, creating a statement's components dynamically, and passing them to the DSL API statically is usually a better choice. See the manual's section about dynamic SQL for details: https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql.
Drawbacks of referencing the XYZ*Step types directly:
- They're operating on mutable implementations (as of jOOQ 3.x)
- They're less composable and not easy to get right when dynamic SQL gets complex
- They're less readable
- They might have binary incompatible changes between minor releases
Author:

Lukas Eder

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`@NotNull SelectJoinStep<R>`	`crossApply(Name name)` `CROSS APPLY` a table to this table.
`@NotNull SelectJoinStep<R>`	`crossApply(SQL sql)` `CROSS APPLY` a table to this table.
`@NotNull SelectJoinStep<R>`	`crossApply(String sql)` `CROSS APPLY` a table to this table.
`@NotNull SelectJoinStep<R>`	`crossApply(String sql, Object... bindings)` `CROSS APPLY` a table to this table.
`@NotNull SelectJoinStep<R>`	`crossApply(String sql, QueryPart... parts)` `CROSS APPLY` a table to this table.
`@NotNull SelectJoinStep<R>`	`crossApply(TableLike<?> table)` `CROSS APPLY` a table to this table.
`@NotNull 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`.
`@NotNull 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`.
`@NotNull 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`.
`@NotNull 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...)`
`@NotNull 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...)`
`@NotNull 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`.
`@NotNull SelectOnStep<R>`	`fullJoin(Name name)` Convenience method to `FULL OUTER JOIN` a tableto the last table added to the `FROM` clause using `Table.fullOuterJoin(Name)`.
`@NotNull SelectOnStep<R>`	`fullJoin(SQL sql)` Convenience method to `FULL OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.fullOuterJoin(String)`.
`@NotNull SelectOnStep<R>`	`fullJoin(String sql)` Convenience method to `FULL OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.fullOuterJoin(String)`.
`@NotNull SelectOnStep<R>`	`fullJoin(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...)`.
`@NotNull SelectOnStep<R>`	`fullJoin(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...)`.
`@NotNull SelectOnStep<R>`	`fullJoin(TableLike<?> table)` Convenience method to `FULL OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.fullOuterJoin(TableLike)`.
`@NotNull 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
`@NotNull 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.
`@NotNull 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.
`@NotNull 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...)`
`@NotNull 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...)`
`@NotNull 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
`@NotNull 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)`.
`@NotNull 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)`.
`@NotNull 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)`.
`@NotNull 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...)`.
`@NotNull 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...)`.
`@NotNull 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)`.
`@NotNull 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)`.
`@NotNull 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)`.
`@NotNull 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)`.
`@NotNull 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...)`.
`@NotNull 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...)`.
`@NotNull 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)`.
`@NotNull 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.
`@NotNull SelectOnStep<R>`	`leftAntiJoin(TableLike<?> table)` A synthetic `LEFT ANTI JOIN` clause that translates to an equivalent `NOT EXISTS` predicate.
`@NotNull 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)`.
`@NotNull 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)`.
`@NotNull 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)`.
`@NotNull 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...)`.
`@NotNull 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...)`.
`@NotNull 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)`.
`@NotNull 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)`
`@NotNull 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.
`@NotNull 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.
`@NotNull 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...)`
`@NotNull 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...)`
`@NotNull 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)`
`@NotNull SelectOnStep<R>`	`leftSemiJoin(TableLike<?> table)` A synthetic `LEFT SEMI JOIN` clause that translates to an equivalent `EXISTS` predicate.
`@NotNull SelectJoinStep<R>`	`naturalFullOuterJoin(Name name)` Convenience method to `NATURAL FULL OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalFullOuterJoin(Name)` Natural joins are supported by most RDBMS.
`@NotNull SelectJoinStep<R>`	`naturalFullOuterJoin(SQL sql)` Convenience method to `NATURAL FULL OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalFullOuterJoin(String)` Natural joins are supported by most RDBMS.
`@NotNull SelectJoinStep<R>`	`naturalFullOuterJoin(String sql)` Convenience method to `NATURAL FULL OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalFullOuterJoin(String)` Natural joins are supported by most RDBMS.
`@NotNull SelectJoinStep<R>`	`naturalFullOuterJoin(String sql, Object... bindings)` Convenience method to `NATURAL FULL OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalFullOuterJoin(String, Object...)`
`@NotNull SelectJoinStep<R>`	`naturalFullOuterJoin(String sql, QueryPart... parts)` Convenience method to `NATURAL FULL OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalFullOuterJoin(String, QueryPart...)`
`@NotNull SelectJoinStep<R>`	`naturalFullOuterJoin(TableLike<?> table)` Convenience method to `NATURAL FULL OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalFullOuterJoin(TableLike)` Natural joins are supported by most RDBMS.
`@NotNull 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.
`@NotNull 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.
`@NotNull 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.
`@NotNull 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...)`
`@NotNull 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...)`
`@NotNull 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.
`@NotNull 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.
`@NotNull 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.
`@NotNull 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.
`@NotNull 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...)`
`@NotNull 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...)`
`@NotNull 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.
`@NotNull 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.
`@NotNull 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.
`@NotNull 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.
`@NotNull 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...)`
`@NotNull 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...)`
`@NotNull 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.
`@NotNull SelectJoinStep<R>`	`outerApply(Name name)` `OUTER APPLY` a table to this table.
`@NotNull SelectJoinStep<R>`	`outerApply(SQL sql)` `OUTER APPLY` a table to this table.
`@NotNull SelectJoinStep<R>`	`outerApply(String sql)` `OUTER APPLY` a table to this table.
`@NotNull SelectJoinStep<R>`	`outerApply(String sql, Object... bindings)` `OUTER APPLY` a table to this table.
`@NotNull SelectJoinStep<R>`	`outerApply(String sql, QueryPart... parts)` `OUTER APPLY` a table to this table.
`@NotNull SelectJoinStep<R>`	`outerApply(TableLike<?> table)` `OUTER APPLY` a table to this table.
`@NotNull 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)`.
`@NotNull 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)`.
`@NotNull 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)`.
`@NotNull 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...)`.
`@NotNull 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...)`.
`@NotNull 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)`.
`@NotNull 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
`@NotNull 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.
`@NotNull 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.
`@NotNull 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...)`
`@NotNull 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...)`
`@NotNull 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
`@NotNull SelectOnStep<R>`	`straightJoin(Name name)` `STRAIGHT_JOIN` a table to this table.
`@NotNull SelectOnStep<R>`	`straightJoin(SQL sql)` `STRAIGHT_JOIN` a table to this table.
`@NotNull SelectOnStep<R>`	`straightJoin(String sql)` `STRAIGHT_JOIN` a table to this table.
`@NotNull SelectOnStep<R>`	`straightJoin(String sql, Object... bindings)` `STRAIGHT_JOIN` a table to this table.
`@NotNull SelectOnStep<R>`	`straightJoin(String sql, QueryPart... parts)` `STRAIGHT_JOIN` a table to this table.
`@NotNull 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, where, whereExists, whereNotExists

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

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

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

Methods inherited from interface org.jooq.SelectQualifyStep
qualify, qualify, qualify, qualify, qualify, qualify, qualify, qualify

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

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

Methods inherited from interface org.jooq.SelectForUpdateStep
forKeyShare, forNoKeyUpdate, forShare, forUpdate

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.SelectCorrelatedSubqueryStep
between, between, between, between, betweenSymmetric, betweenSymmetric, betweenSymmetric, betweenSymmetric, compare, compare, compare, eq, eq, eq, equal, equal, equal, ge, ge, ge, greaterOrEqual, greaterOrEqual, greaterOrEqual, greaterThan, greaterThan, greaterThan, gt, gt, gt, in, in, isDistinctFrom, isDistinctFrom, isDistinctFrom, isNotDistinctFrom, isNotDistinctFrom, isNotDistinctFrom, isNotNull, isNull, le, le, le, lessOrEqual, lessOrEqual, lessOrEqual, lessThan, lessThan, lessThan, lt, lt, lt, ne, ne, ne, notBetween, notBetween, notBetween, notBetween, notBetweenSymmetric, notBetweenSymmetric, notBetweenSymmetric, notBetweenSymmetric, notEqual, notEqual, notEqual, notIn, notIn

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, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, coerce, collect, 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, 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, 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, fetchSet, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingle, fetchSingleArray, fetchSingleInto, fetchSingleInto, fetchSingleMap, fetchSize, fetchStream, fetchStreamInto, fetchStreamInto, forEach, getRecordType, getResult, intern, intern, intern, intern, iterator, keepStatement, maxRows, poolable, queryTimeout, resultSetConcurrency, resultSetHoldability, resultSetType, spliterator, 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, configuration, detach

Methods inherited from interface org.reactivestreams.Publisher
subscribe

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

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

- Method Detail
  - join
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.join(String, Object...), innerJoin(String, Object...), SQL
  - join
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.join(String, QueryPart...), innerJoin(String, QueryPart...), SQL
  - join
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.innerJoin(String, Object...), SQL
  - innerJoin
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.innerJoin(String, QueryPart...), SQL
  - innerJoin
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.crossJoin(String, Object...), SQL
  - crossJoin
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.crossJoin(String, QueryPart...), SQL
  - crossJoin
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.leftOuterJoin(String, Object...), leftOuterJoin(String, Object...), SQL
  - leftJoin
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.leftOuterJoin(String, QueryPart...), leftOuterJoin(String, QueryPart...), SQL
  - leftJoin
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.leftOuterJoin(String, Object...), SQL
  - leftOuterJoin
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.leftOuterJoin(String, QueryPart...), SQL
  - leftOuterJoin
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.rightOuterJoin(String, Object...), rightOuterJoin(String, Object...), SQL
  - rightJoin
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.rightOuterJoin(String, QueryPart...), rightOuterJoin(String, QueryPart...), SQL
  - rightJoin
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.rightOuterJoin(String, Object...), SQL
  - rightOuterJoin
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.rightOuterJoin(String, QueryPart...), SQL
  - rightOuterJoin
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
@NotNull 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)
  - fullJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
@NotNull SelectOnStep<R> fullJoin(TableLike<?> table)
```
    Convenience method to FULL OUTER JOIN a table to the last table added to the FROM clause using Table.fullOuterJoin(TableLike).
    A synonym for fullOuterJoin(TableLike).
  - fullJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull SelectOnStep<R> fullJoin(SQL sql)
```
    Convenience method to FULL OUTER JOIN a table to the last table added to the FROM clause using Table.fullOuterJoin(String).
    A synonym for fullOuterJoin(SQL).
    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!
  - fullJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull SelectOnStep<R> fullJoin(String sql)
```
    Convenience method to FULL OUTER JOIN a table to the last table added to the FROM clause using Table.fullOuterJoin(String).
    A synonym for fullOuterJoin(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!
  - fullJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull SelectOnStep<R> fullJoin(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...).
    A synonym for fullOuterJoin(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!
  - fullJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull SelectOnStep<R> fullJoin(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...).
    A synonym for fullOuterJoin(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!
  - fullJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
@NotNull SelectOnStep<R> fullJoin(Name name)
```
    Convenience method to FULL OUTER JOIN a tableto the last table added to the FROM clause using Table.fullOuterJoin(Name).
    A synonym for fullOuterJoin(Name).
  - fullOuterJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
@NotNull 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
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.fullOuterJoin(String, Object...), SQL
  - fullOuterJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.fullOuterJoin(String, QueryPart...), SQL
  - fullOuterJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
@NotNull 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
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.naturalJoin(String, Object...), SQL
  - naturalJoin
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.naturalJoin(String, QueryPart...), SQL
  - naturalJoin
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.naturalLeftOuterJoin(String, Object...), SQL
  - naturalLeftOuterJoin
```
@NotNull
 @Support
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.naturalLeftOuterJoin(String, QueryPart...), SQL
  - naturalLeftOuterJoin
```
@NotNull
 @Support
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.naturalRightOuterJoin(String, Object...), SQL
  - naturalRightOuterJoin
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.naturalRightOuterJoin(String, QueryPart...), SQL
  - naturalRightOuterJoin
```
@NotNull
 @Support(value={CUBRID,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL,POSTGRES})
@NotNull 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)
  - naturalFullOuterJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
@NotNull SelectJoinStep<R> naturalFullOuterJoin(TableLike<?> table)
```
    Convenience method to NATURAL FULL OUTER JOIN a table to the last table added to the FROM clause using Table.naturalFullOuterJoin(TableLike)
    Natural joins are supported by most RDBMS. If they aren't supported, they are emulated if jOOQ has enough information.
    
    See Also:
    
    Table.naturalFullOuterJoin(TableLike)
  - naturalFullOuterJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull SelectJoinStep<R> naturalFullOuterJoin(SQL sql)
```
    Convenience method to NATURAL FULL OUTER JOIN a table to the last table added to the FROM clause using Table.naturalFullOuterJoin(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.naturalFullOuterJoin(SQL), SQL
  - naturalFullOuterJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull SelectJoinStep<R> naturalFullOuterJoin(String sql)
```
    Convenience method to NATURAL FULL OUTER JOIN a table to the last table added to the FROM clause using Table.naturalFullOuterJoin(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.naturalFullOuterJoin(String), SQL
  - naturalFullOuterJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull SelectJoinStep<R> naturalFullOuterJoin(String sql,
                                                                                                                   Object... bindings)
```
    Convenience method to NATURAL FULL OUTER JOIN a table to the last table added to the FROM clause using Table.naturalFullOuterJoin(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...), DSL.sql(String, Object...), Table.naturalFullOuterJoin(String, Object...), SQL
  - naturalFullOuterJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
 @PlainSQL
@NotNull SelectJoinStep<R> naturalFullOuterJoin(String sql,
                                                                                                                   QueryPart... parts)
```
    Convenience method to NATURAL FULL OUTER JOIN a table to the last table added to the FROM clause using Table.naturalFullOuterJoin(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...), DSL.sql(String, QueryPart...), Table.naturalFullOuterJoin(String, QueryPart...), SQL
  - naturalFullOuterJoin
```
@NotNull
 @Support(value={FIREBIRD,HSQLDB,POSTGRES})
@NotNull SelectJoinStep<R> naturalFullOuterJoin(Name name)
```
    Convenience method to NATURAL FULL OUTER JOIN a table to the last table added to the FROM clause using Table.naturalFullOuterJoin(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.naturalFullOuterJoin(Name)
  - leftSemiJoin
```
@NotNull
 @Support
@NotNull 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
 )
 
```
    Notice that according to Relational algebra's understanding of left semi join, the right hand side of the left semi join operator is not projected, i.e. it cannot be accessed from WHERE or SELECT or any other clause than ON.
    See Also:
    
    Table.leftSemiJoin(TableLike)
  - leftAntiJoin
```
@NotNull
 @Support
@NotNull 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
 )
 
```
    Notice that according to Relational algebra's understanding of left semi join, the right hand side of the left semi join operator is not projected, i.e. it cannot be accessed from WHERE or SELECT or any other clause than ON.
    See Also:
    
    Table.leftAntiJoin(TableLike)
  - crossApply
```
@NotNull
 @Support(value=POSTGRES)
@NotNull SelectJoinStep<R> crossApply(TableLike<?> table)
```
    CROSS APPLY a table to this table.
    
    See Also:
    
    Table.crossApply(TableLike)
  - crossApply
```
@NotNull
 @Support(value=POSTGRES)
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value=POSTGRES)
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value=POSTGRES)
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.crossApply(String, Object...), SQL
  - crossApply
```
@NotNull
 @Support(value=POSTGRES)
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.crossApply(String, QueryPart...), SQL
  - crossApply
```
@NotNull
 @Support(value=POSTGRES)
@NotNull SelectJoinStep<R> crossApply(Name name)
```
    CROSS APPLY a table to this table.
    
    See Also:
    
    DSL.table(Name), Table.crossApply(Name)
  - outerApply
```
@NotNull
 @Support(value=POSTGRES)
@NotNull SelectJoinStep<R> outerApply(TableLike<?> table)
```
    OUTER APPLY a table to this table.
    
    See Also:
    
    Table.outerApply(TableLike)
  - outerApply
```
@NotNull
 @Support(value=POSTGRES)
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value=POSTGRES)
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value=POSTGRES)
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.outerApply(String, Object...), SQL
  - outerApply
```
@NotNull
 @Support(value=POSTGRES)
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.outerApply(String, QueryPart...), SQL
  - outerApply
```
@NotNull
 @Support(value=POSTGRES)
@NotNull SelectJoinStep<R> outerApply(Name name)
```
    OUTER APPLY a table to this table.
    
    See Also:
    
    DSL.table(Name), Table.outerApply(Name)
  - straightJoin
```
@NotNull
 @Support(value=MYSQL)
@NotNull SelectOnStep<R> straightJoin(TableLike<?> table)
```
    STRAIGHT_JOIN a table to this table.
    
    See Also:
    
    Table.straightJoin(TableLike)
  - straightJoin
```
@NotNull
 @Support(value=MYSQL)
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value=MYSQL)
 @PlainSQL
@NotNull 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
```
@NotNull
 @Support(value=MYSQL)
 @PlainSQL
@NotNull 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...), DSL.sql(String, Object...), Table.straightJoin(String, Object...)
  - straightJoin
```
@NotNull
 @Support(value=MYSQL)
 @PlainSQL
@NotNull 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...), DSL.sql(String, QueryPart...), Table.straightJoin(String, QueryPart...)
  - straightJoin
```
@NotNull
 @Support(value=MYSQL)
@NotNull 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>

Referencing XYZ*Step types directly from client code

Method Summary

Methods inherited from interface org.jooq.SelectWhereStep

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

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

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 org.reactivestreams.Publisher

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

fullJoin

fullJoin

fullJoin

fullJoin

fullJoin

fullJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

naturalJoin

Referencing `XYZ*Step` types directly from client code