SelectJoinStep (jOOQ 3.0.1 API)

All Superinterfaces:: Attachable, FieldLike, Query, QueryPart, ResultQuery<R>, Select<R>, SelectConnectByStep<R>, SelectFinalStep<R>, SelectForUpdateStep<R>, SelectGroupByStep<R>, SelectHavingStep<R>, SelectLimitStep<R>, SelectOrderByStep<R>, SelectWhereStep<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

Methods
Modifier and Type	Method and Description
`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 simulated 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 simulated with a regular `INNER JOIN`.
`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>`	`join(String sql)` Convenience method to `INNER JOIN` a table to the last table added to the `FROM` clause using `Table.join(String)` NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectOnStep<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.
`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)`
`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(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(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.
`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

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

Methods inherited from interface org.jooq.SelectConnectByStep
connectBy, connectBy, connectBy, connectBy, 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

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

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

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

Methods inherited from interface org.jooq.SelectFinalStep
getQuery

Methods inherited from interface org.jooq.Select
except, fetchCount, getSelect, intersect, union, unionAll

Methods inherited from interface org.jooq.ResultQuery
bind, bind, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetch, fetchAny, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArray, fetchArrays, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchGroups, fetchInto, fetchInto, fetchInto, fetchLater, fetchLater, fetchLazy, fetchLazy, fetchMany, fetchMap, fetchMap, fetchMap, fetchMap, fetchMap, fetchMaps, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOne, fetchOneArray, fetchOneInto, fetchOneInto, fetchOneMap, fetchResultSet, getRecordType, getResult, intern, intern, intern, keepStatement, maxRows, queryTimeout

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

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

Methods inherited from interface org.jooq.Attachable
attach

Methods inherited from interface org.jooq.TableLike
asTable, asTable, asTable, field, field, field, 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)
    
    See Also:
    Table.join(TableLike)
  - join
```
@Support
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)
    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)
  - join
```
@Support
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...)
    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...)
  - join
```
@Support
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...)
    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...)
  - crossJoin
```
@Support
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 simulated 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
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 simulated with a regular INNER JOIN. The following two constructs are equivalent:
```
 A cross join B
 A join B on 1 = 1
 
```
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    See Also:
    DSL.table(String), Table.crossJoin(String)
  - crossJoin
```
@Support
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 simulated with a regular INNER JOIN. The following two constructs are equivalent:
```
 A cross join B
 A join B on 1 = 1
 
```
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    See Also:
    DSL.table(String, Object...), Table.crossJoin(String, Object...)
  - crossJoin
```
@Support
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 simulated with a regular INNER JOIN. The following two constructs are equivalent:
```
 A cross join B
 A join B on 1 = 1
 
```
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    See Also:
    DSL.table(String, QueryPart...), Table.crossJoin(String, QueryPart...)
  - 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
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)
  - leftOuterJoin
```
@Support
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...)
  - leftOuterJoin
```
@Support
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...)
  - rightOuterJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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)
  - rightOuterJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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...)
  - rightOuterJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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...)
  - fullOuterJoin
```
@Support(value={DB2,FIREBIRD,HSQLDB,INGRES,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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,HSQLDB,INGRES,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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)
  - fullOuterJoin
```
@Support(value={DB2,FIREBIRD,HSQLDB,INGRES,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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...)
  - fullOuterJoin
```
@Support(value={DB2,FIREBIRD,HSQLDB,INGRES,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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...)
  - 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 simulated if jOOQ has enough information.
    
    See Also:
    Table.naturalJoin(TableLike)
  - naturalJoin
```
@Support
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 simulated if jOOQ has enough information.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    DSL.table(String), Table.naturalJoin(String)
  - naturalJoin
```
@Support
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 simulated if jOOQ has enough information.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    DSL.table(String, Object...), Table.naturalJoin(String, Object...)
  - naturalJoin
```
@Support
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 simulated if jOOQ has enough information.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    DSL.table(String, QueryPart...), Table.naturalJoin(String, QueryPart...)
  - 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 simulated if jOOQ has enough information.
    
    See Also:
    Table.naturalLeftOuterJoin(TableLike)
  - naturalLeftOuterJoin
```
@Support
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 simulated if jOOQ has enough information.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    DSL.table(String), Table.naturalLeftOuterJoin(String)
  - naturalLeftOuterJoin
```
@Support
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 simulated if jOOQ has enough information.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    DSL.table(String, Object...), Table.naturalLeftOuterJoin(String, Object...)
  - naturalLeftOuterJoin
```
@Support
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 simulated if jOOQ has enough information.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    DSL.table(String, QueryPart...), Table.naturalLeftOuterJoin(String, QueryPart...)
  - naturalRightOuterJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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 simulated if jOOQ has enough information.
    
    See Also:
    Table.naturalRightOuterJoin(TableLike)
  - naturalRightOuterJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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 simulated if jOOQ has enough information.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    DSL.table(String), Table.naturalRightOuterJoin(String)
  - naturalRightOuterJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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 simulated if jOOQ has enough information.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    DSL.table(String, Object...), Table.naturalRightOuterJoin(String, Object...)
  - naturalRightOuterJoin
```
@Support(value={ASE,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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 simulated if jOOQ has enough information.
    NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
    
    See Also:
    DSL.table(String, QueryPart...), Table.naturalRightOuterJoin(String, QueryPart...)

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

Methods inherited from interface org.jooq.SelectLimitStep

Methods inherited from interface org.jooq.SelectForUpdateStep

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.jooq.TableLike

Methods inherited from interface org.jooq.FieldLike

Method Detail

join

join

join

join

join

crossJoin

crossJoin

crossJoin

crossJoin

leftOuterJoin

leftOuterJoin

leftOuterJoin

leftOuterJoin

rightOuterJoin

rightOuterJoin

rightOuterJoin

rightOuterJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

fullOuterJoin

naturalJoin

naturalJoin

naturalJoin

naturalJoin

naturalLeftOuterJoin

naturalLeftOuterJoin

naturalLeftOuterJoin

naturalLeftOuterJoin

naturalRightOuterJoin

naturalRightOuterJoin

naturalRightOuterJoin

naturalRightOuterJoin