SelectImpl (queryman-builder API)

java.lang.Object
- org.queryman.builder.AbstractQuery
- - org.queryman.builder.command.impl.SelectImpl

All Implemented Interfaces:

AstVisitor, SelectCombiningQueryStep, SelectFinalStep, SelectFromStep, SelectGroupByStep, SelectHavingFirstStep, SelectHavingManySteps, SelectJoinManyStepsStep, SelectJoinOnFirstStep, SelectJoinOnManySteps, SelectJoinStep, SelectLimitStep, SelectLockingManySteps, SelectLockingOfTableStep, SelectLockingStep, SelectLockingWaitingStep, SelectOffsetStep, SelectOrderByStep, SelectWhereFirstStep, SelectWhereManySteps, Query
```
public class SelectImpl
extends AbstractQuery
implements SelectFromStep, SelectJoinStep, SelectJoinOnFirstStep, SelectJoinOnManySteps, SelectWhereManySteps, SelectGroupByStep, SelectHavingFirstStep, SelectHavingManySteps, SelectOrderByStep, SelectLimitStep, SelectOffsetStep, SelectLockingStep, SelectLockingOfTableStep, SelectLockingWaitingStep, SelectLockingManySteps, SelectFinalStep
```

Constructor Summary

Constructors
Constructor	Description
`SelectImpl(java.lang.String... columnsSelected)`
`SelectImpl(java.util.List<Expression> names)`
`SelectImpl(Expression... columnsSelected)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`SelectImpl`	`all()`	Clause SELECT ALL ...
`SelectImpl`	`and(Conditions conditions)`	For full information see the `Conditions.and(Conditions)` method.
`<T> SelectImpl`	`and(T left, T operator, T right)`	For full information see the `Conditions.and(Object, Object, Object)` method.
`SelectImpl`	`andExists(Query query)`	For full information see the `Conditions.andExists(Query)` method.
`SelectImpl`	`andNot(Conditions conditions)`	For full information see the `Conditions.andNot(Conditions)` method.
`<T> SelectImpl`	`andNot(T left, T operator, T right)`	For full information see the `Conditions.andNot(Object, Object, Object)` method.
`SelectImpl`	`andNotExists(Query query)`	For full information see the `Conditions.andNotExists(Query)` method.
`void`	`assemble(AbstractSyntaxTree tree)`	Visits SQL query making a tree from its clauses.
`SelectImpl`	`crossJoin(java.lang.String name)`
`SelectImpl`	`crossJoin(Expression name)`
`SelectImpl`	`distinct()`	Clause SELECT DISTINCT ...
`SelectImpl`	`distinctOn(java.lang.String... columns)`	Clause SELECT DISTINCT ON ( ..
`SelectImpl`	`distinctOn(Expression... columns)`	Clause SELECT DISTINCT ON ( ..
`SelectImpl`	`except(SelectFinalStep select)`	Combine main query with `select` query using EXCEPT.
`SelectImpl`	`exceptAll(SelectFinalStep select)`	Combine main query with `select` query using EXCEPT ALL.
`SelectImpl`	`forKeyShare()`	Specifies a locking mode name FOR KEY SHARE.
`SelectImpl`	`forNoKeyUpdate()`	Specifies a locking mode name FOR NO KEY UPDATE.
`SelectImpl`	`forShare()`	Specifies a locking mode name FOR SHARE.
`SelectImpl`	`forUpdate()`	Specifies a locking mode name FOR UPDATE.
`SelectImpl`	`from(java.lang.String... tables)`	Specify table name that be used to retrieve rows.
`SelectImpl`	`from(From... tables)`	Specify table name that be used to retrieve rows.
`SelectImpl`	`from(Expression... tables)`	Specify table name that be used to retrieve rows.
`SelectImpl`	`fullJoin(java.lang.String name)`
`SelectImpl`	`fullJoin(Expression name)`
`SelectImpl`	`groupBy(java.lang.String... expressions)`
`SelectImpl`	`groupBy(Expression... expressions)`
`SelectImpl`	`having(Conditions conditions)`	This function useful in a few case: When the `conditions` is a special case of condition, like `Queryman.conditionBetween(Object, Object, Object)`, or `Queryman.conditionSome(Object, Object, Query)` etc.
`<T> SelectImpl`	`having(T left, T operator, T right)`	Example: `// SELECT year FROM book HAVING year > 2010 select("year", "id") .from("book") .having("year", ">", "2010") .sql()`
`SelectImpl`	`havingExists(Query query)`	Example: `// SELECT * FROM book HAVING EXISTS (SELECT * FROM author) select("") .from("book") .havingExists(select("").from("authors")) .sql()`
`SelectImpl`	`innerJoin(java.lang.String name)`
`SelectImpl`	`innerJoin(Expression name)`
`SelectImpl`	`intersect(SelectFinalStep select)`	Combine main query with `select` query using INTERSECT.
`SelectImpl`	`intersectAll(SelectFinalStep select)`	Combine main query with `select` query using INTERSECT ALL.
`SelectImpl`	`join(java.lang.String name)`
`SelectImpl`	`join(Expression name)`
`SelectImpl`	`leftJoin(java.lang.String name)`
`SelectImpl`	`leftJoin(Expression name)`
`SelectImpl`	`limit(long limit)`
`SelectImpl`	`limit(Expression limit)`
`SelectImpl`	`naturalJoin(java.lang.String name)`
`SelectImpl`	`naturalJoin(Expression name)`
`SelectImpl`	`noWait()`	Specifies NOWAIT mode, meaning the SELECT statement will report an error, if rows are locked, rather than will wait for rows.
`SelectImpl`	`of(java.lang.String... tables)`	Specifies tables, rows of those are locking.
`SelectImpl`	`of(Expression... tables)`	Specifies tables, rows of those are locking.
`SelectImpl`	`offset(long offset)`	Specifies the offset start.
`SelectImpl`	`offset(Expression offset)`	Specifies the offset start.
`SelectImpl`	`on(boolean conditions)`	This form of JOIN ON condition is equivalent to CROSS JOIN.
`SelectImpl`	`on(Conditions conditions)`
`<T> SelectImpl`	`on(T left, T operator, T right)`	Example: `// SELECT * FROM book AS b JOIN author a ON a.id = b.author_id select("*") .from(asName("book").as("b")) .join("author a") .on("a.id", "=", "b.author_id") .sql()`
`SelectImpl`	`onExists(Query query)`
`SelectImpl`	`or(Conditions conditions)`	For full information see the `Conditions.or(Conditions)` method.
`<T> SelectImpl`	`or(T left, T operator, T right)`	For full information see the `Conditions.or(Object, Object, Object)` method.
`SelectImpl`	`orderBy(java.lang.String column)`	Specifies an ordering of output
`SelectImpl`	`orderBy(java.lang.String column, java.lang.String sorting)`	Specifies an ordering of output
`SelectImpl`	`orderBy(java.lang.String column, java.lang.String sorting, java.lang.String nulls)`	Specifies an ordering of output.
`SelectImpl`	`orderBy(OrderBy... ordersBy)`	Specifies an ordering of output.
`SelectImpl`	`orExists(Query query)`	For full information see the `Conditions.orExists(Query)` method.
`SelectImpl`	`orNot(Conditions conditions)`	For full information see the `Conditions.orNot(Conditions)` method.
`<T> SelectImpl`	`orNot(T left, T operator, T right)`	For full information see the `Conditions.orNot(Object, Object, Object)` method.
`SelectImpl`	`orNotExists(Query query)`	For full information see the `Conditions.orNot(Conditions)` method.
`SelectImpl`	`rightJoin(java.lang.String name)`
`SelectImpl`	`rightJoin(Expression name)`
`SelectImpl`	`skipLocked()`	Specifies SKIP LOCKED mode, meaning the SELECT statement will omit the locked rows.
`SelectImpl`	`union(SelectFinalStep select)`	Combine main query with `select` query using UNION.
`SelectImpl`	`unionAll(SelectFinalStep select)`	Combine main query with `select` query using UNION ALL.
`SelectImpl`	`using(java.lang.String... name)`	Example: `// SELECT * FROM book JOIN author USING (id) select("*") .from("book") .join("author") .using("id") .sql()`
`SelectImpl`	`using(Expression... columns)`	Example: `// SELECT * FROM book JOIN author USING (id) select("*") .from(asName("book")) .join("author") .using(asName("id")) .sql()`
`SelectImpl`	`where(Conditions conditions)`	This function useful in a few case: When the `conditions` is a special case of condition, like `Queryman.conditionBetween(Object, Object, Object)`, or `Queryman.conditionSome(Object, Object, Query)` etc.
`<T> SelectImpl`	`where(T left, T operator, T right)`	Example: `// SELECT * FROM book WHERE year > 2010 select("*") .from("book") .where("year", ">", "2010") .sql()`
`SelectImpl`	`whereExists(Query query)`	Example: `// SELECT * FROM book WHERE EXISTS (SELECT * FROM author) select("") .from("book") .whereExists(select("").from("authors")) .sql()`

Methods inherited from class org.queryman.builder.AbstractQuery
buildPreparedStatement, sql, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.queryman.builder.Query
buildPreparedStatement, sql

- Constructor Detail
  - SelectImpl
```
public SelectImpl(java.lang.String... columnsSelected)
```
  - SelectImpl
```
public SelectImpl(java.util.List<Expression> names)
```
  - SelectImpl
```
public SelectImpl(Expression... columnsSelected)
```
- Method Detail
  - all
```
public final SelectImpl all()
```
    Clause SELECT ALL ...
  - distinct
```
public final SelectImpl distinct()
```
    Clause SELECT DISTINCT ...
  - distinctOn
```
public final SelectImpl distinctOn(java.lang.String... columns)
```
    Clause SELECT DISTINCT ON ( .. ) ...
  - distinctOn
```
public final SelectImpl distinctOn(Expression... columns)
```
    Clause SELECT DISTINCT ON ( .. ) ...
  - assemble
```
public final void assemble(AbstractSyntaxTree tree)
```
    Description copied from interface: AstVisitor
    
    Visits SQL query making a tree from its clauses.
    
    Specified by:
    
    assemble in interface AstVisitor
    
    Parameters:
    
    tree - - abstract syntax tree
  - from
```
public final SelectImpl from(java.lang.String... tables)
```
    Description copied from interface: SelectFromStep
    
    Specify table name that be used to retrieve rows. If several names are provided, they will be cross-joined together. It you'd like to use an alias, it must be followed by table name: select("id").from("books as b") select("id").from("books as b (id, name)")
    
    Specified by:
    
    from in interface SelectFromStep
    
    See Also:
    
    SelectFromStep.from(Expression...), SelectFromStep.from(From...)
  - from
```
public final SelectImpl from(Expression... tables)
```
    Description copied from interface: SelectFromStep
    
    Specify table name that be used to retrieve rows. If several names are provided, they will be cross-joined together. It you'd like to use an alias, it must be followed by table name: Queryman.asName("books").as("b"); // books AS b Queryman.asName("books").as("b", "id", "name"); // books AS b(id, name)
    
    Specified by:
    
    from in interface SelectFromStep
    
    See Also:
    
    SelectFromStep.from(String...), SelectFromStep.from(From...), Expression
  - from
```
public final SelectImpl from(From... tables)
```
    Description copied from interface: SelectFromStep
    
    Specify table name that be used to retrieve rows. If several names are provided, they will be cross-joined together. It you'd like to use an alias, it must be followed by table name: Queryman.from("books").as("b"); // books AS b Queryman.from("books").as("b", "id", "name"); // books AS b(id, name) Queryman.fromOnly("books"); // ONLY books
    
    Specified by:
    
    from in interface SelectFromStep
    
    See Also:
    
    SelectFromStep.from(Expression...), SelectFromStep.from(String...), Queryman.from(String), Queryman.from(Expression), Queryman.fromOnly(String), Queryman.fromOnly(Expression)
  - where
```
public final <T> SelectImpl where(T left,
                                  T operator,
                                  T right)
```
    Description copied from interface: SelectWhereFirstStep
    
    Example: // SELECT * FROM book WHERE year > 2010 select("*") .from("book") .where("year", ">", "2010") .sql()
    
    Specified by:
    
    where in interface SelectWhereFirstStep
    
    Type Parameters:
    
    T - String, Expression, Operator or Query object
    
    Parameters:
    
    left - left operand
    
    operator - operator
    
    right - right operand
  - where
```
public final SelectImpl where(Conditions conditions)
```
    Description copied from interface: SelectWhereFirstStep
    This function useful in a few case:
    - When the conditions is a special case of condition, like Queryman.conditionBetween(Object, Object, Object), or Queryman.conditionSome(Object, Object, Query) etc. See the first example.
    - When the conditions is a group of conditions are joined by AND, AND NOT, OR and OR NOT operators. These conditions are being a grouped condition, and will be surrounded by parentheses. See the second example.
    The first example: // SELECT * FROM book WHERE id BETWEEN 1 AND 10 select("*") .from("book") .where(conditionBetween("id", "1", "10")) .sql() The second example: // SELECT * FROM book WHERE (id BETWEEN 1 AND 10 AND name = 'Advanced SQL') select("*") .from("book") .where( conditionBetween("id", "1", "10") .and(asName("name"), operator("="), asString("Advanced SQL")) ) .sql()
    Specified by:
    
    where in interface SelectWhereFirstStep
    
    Parameters:
    
    conditions - condition
    
    Returns:
    
    itself Kind of conditions:
    
    See Also:
    
    Queryman.condition(Object, Object, Object)
  - whereExists
```
public final SelectImpl whereExists(Query query)
```
    Description copied from interface: SelectWhereFirstStep
    
    Example: // SELECT * FROM book WHERE EXISTS (SELECT * FROM author) select("*") .from("book") .whereExists(select("*").from("authors")) .sql()
    
    Specified by:
    
    whereExists in interface SelectWhereFirstStep
    
    Parameters:
    
    query - subquery
    
    Returns:
    
    itself
  - and
```
public final <T> SelectImpl and(T left,
                                T operator,
                                T right)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.and(Object, Object, Object) method.
    
    Specified by:
    
    and in interface SelectHavingManySteps
    
    Specified by:
    
    and in interface SelectJoinOnManySteps
    
    Specified by:
    
    and in interface SelectWhereManySteps
    
    Type Parameters:
    
    T - String, Expression, Operator or Query object
    
    Parameters:
    
    left - left operand
    
    operator - operator
    
    right - right operand
    
    Returns:
    
    itself
  - and
```
public final SelectImpl and(Conditions conditions)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.and(Conditions) method.
    
    Specified by:
    
    and in interface SelectHavingManySteps
    
    Specified by:
    
    and in interface SelectJoinOnManySteps
    
    Specified by:
    
    and in interface SelectWhereManySteps
    
    Parameters:
    
    conditions - conditions
    
    Returns:
    
    itself
  - andExists
```
public final SelectImpl andExists(Query query)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.andExists(Query) method.
    
    Specified by:
    
    andExists in interface SelectHavingManySteps
    
    Specified by:
    
    andExists in interface SelectJoinOnManySteps
    
    Specified by:
    
    andExists in interface SelectWhereManySteps
    
    Parameters:
    
    query - subquery
    
    Returns:
    
    itself
  - andNot
```
public final <T> SelectImpl andNot(T left,
                                   T operator,
                                   T right)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.andNot(Object, Object, Object) method.
    
    Specified by:
    
    andNot in interface SelectHavingManySteps
    
    Specified by:
    
    andNot in interface SelectJoinOnManySteps
    
    Specified by:
    
    andNot in interface SelectWhereManySteps
    
    Type Parameters:
    
    T - String, Expression, Operator or Query object
    
    Parameters:
    
    left - left operand
    
    operator - operator
    
    right - right operand
    
    Returns:
    
    itself
  - andNot
```
public final SelectImpl andNot(Conditions conditions)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.andNot(Conditions) method.
    
    Specified by:
    
    andNot in interface SelectHavingManySteps
    
    Specified by:
    
    andNot in interface SelectJoinOnManySteps
    
    Specified by:
    
    andNot in interface SelectWhereManySteps
    
    Parameters:
    
    conditions - conditions
    
    Returns:
    
    itself
  - andNotExists
```
public final SelectImpl andNotExists(Query query)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.andNotExists(Query) method.
    
    Specified by:
    
    andNotExists in interface SelectHavingManySteps
    
    Specified by:
    
    andNotExists in interface SelectJoinOnManySteps
    
    Specified by:
    
    andNotExists in interface SelectWhereManySteps
    
    Parameters:
    
    query - subquery
    
    Returns:
    
    itself
  - or
```
public final <T> SelectImpl or(T left,
                               T operator,
                               T right)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.or(Object, Object, Object) method.
    
    Specified by:
    
    or in interface SelectHavingManySteps
    
    Specified by:
    
    or in interface SelectJoinOnManySteps
    
    Specified by:
    
    or in interface SelectWhereManySteps
    
    Type Parameters:
    
    T - String, Expression, Operator or Query object
    
    Parameters:
    
    left - left operand
    
    operator - operator
    
    right - right operand
    
    Returns:
    
    itself
  - or
```
public final SelectImpl or(Conditions conditions)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.or(Conditions) method.
    
    Specified by:
    
    or in interface SelectHavingManySteps
    
    Specified by:
    
    or in interface SelectJoinOnManySteps
    
    Specified by:
    
    or in interface SelectWhereManySteps
    
    Parameters:
    
    conditions - conditions
    
    Returns:
    
    itself
  - orExists
```
public final SelectImpl orExists(Query query)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.orExists(Query) method.
    
    Specified by:
    
    orExists in interface SelectHavingManySteps
    
    Specified by:
    
    orExists in interface SelectJoinOnManySteps
    
    Specified by:
    
    orExists in interface SelectWhereManySteps
    
    Parameters:
    
    query - subquery
    
    Returns:
    
    itself
  - orNot
```
public final <T> SelectImpl orNot(T left,
                                  T operator,
                                  T right)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.orNot(Object, Object, Object) method.
    
    Specified by:
    
    orNot in interface SelectHavingManySteps
    
    Specified by:
    
    orNot in interface SelectJoinOnManySteps
    
    Specified by:
    
    orNot in interface SelectWhereManySteps
    
    Type Parameters:
    
    T - String, Expression, Operator or Query object
    
    Parameters:
    
    left - left operand
    
    operator - operator
    
    right - right operand
    
    Returns:
    
    itself
  - orNot
```
public final SelectImpl orNot(Conditions conditions)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.orNot(Conditions) method.
    
    Specified by:
    
    orNot in interface SelectHavingManySteps
    
    Specified by:
    
    orNot in interface SelectJoinOnManySteps
    
    Specified by:
    
    orNot in interface SelectWhereManySteps
    
    Parameters:
    
    conditions - conditions
    
    Returns:
    
    itself
  - orNotExists
```
public final SelectImpl orNotExists(Query query)
```
    Description copied from interface: SelectJoinOnManySteps
    
    For full information see the Conditions.orNot(Conditions) method.
    
    Specified by:
    
    orNotExists in interface SelectHavingManySteps
    
    Specified by:
    
    orNotExists in interface SelectJoinOnManySteps
    
    Specified by:
    
    orNotExists in interface SelectWhereManySteps
    
    Parameters:
    
    query - subquery
    
    Returns:
    
    itself
  - groupBy
```
public final SelectImpl groupBy(java.lang.String... expressions)
```
    Specified by:
    
    groupBy in interface SelectGroupByStep
  - groupBy
```
public final SelectImpl groupBy(Expression... expressions)
```
    Specified by:
    
    groupBy in interface SelectGroupByStep
  - orderBy
```
public final SelectImpl orderBy(java.lang.String column)
```
    Description copied from interface: SelectOrderByStep
    
    Specifies an ordering of output
    
    Specified by:
    
    orderBy in interface SelectOrderByStep
    
    Parameters:
    
    column - column name or expression
    
    Returns:
    
    SELECT .. LIMIT .. step
  - orderBy
```
public final SelectImpl orderBy(java.lang.String column,
                                java.lang.String sorting)
```
    Description copied from interface: SelectOrderByStep
    
    Specifies an ordering of output
    
    Specified by:
    
    orderBy in interface SelectOrderByStep
    
    Parameters:
    
    column - column name or expression
    
    sorting - sorting constant: ASC | DESC | USING constant
    
    Returns:
    
    SELECT .. LIMIT .. step
  - orderBy
```
public final SelectImpl orderBy(java.lang.String column,
                                java.lang.String sorting,
                                java.lang.String nulls)
```
    Description copied from interface: SelectOrderByStep
    
    Specifies an ordering of output.
    
    Specified by:
    
    orderBy in interface SelectOrderByStep
    
    Parameters:
    
    column - column name or expression
    
    sorting - sorting constant: ASC | DESC | USING constant
    
    nulls - sets a position a row with null values for name column. It may be FIRST | LAST
    
    Returns:
    
    SELECT .. LIMIT .. step
  - orderBy
```
public final SelectImpl orderBy(OrderBy... ordersBy)
```
    Description copied from interface: SelectOrderByStep
    
    Specifies an ordering of output.
    
    Specified by:
    
    orderBy in interface SelectOrderByStep
    
    Parameters:
    
    ordersBy - list of OrderBy objects.
    
    Returns:
    
    SELECT .. LIMIT .. step
    
    See Also:
    
    Queryman.orderBy(String)
  - limit
```
public final SelectImpl limit(long limit)
```
    Specified by:
    
    limit in interface SelectLimitStep
  - limit
```
public final SelectImpl limit(Expression limit)
```
    Specified by:
    
    limit in interface SelectLimitStep
  - offset
```
public final SelectImpl offset(long offset)
```
    Description copied from interface: SelectOffsetStep
    
    Specifies the offset start.
    
    Specified by:
    
    offset in interface SelectOffsetStep
    
    Parameters:
    
    offset - offset start
    
    Returns:
    
    select locking step
    
    See Also:
    
    SelectOffsetStep.offset(Expression)
  - offset
```
public final SelectImpl offset(Expression offset)
```
    Description copied from interface: SelectOffsetStep
    
    Specifies the offset start.
    
    Specified by:
    
    offset in interface SelectOffsetStep
    
    Parameters:
    
    offset - offset start
    
    Returns:
    
    select locking step
  - join
```
public final SelectImpl join(java.lang.String name)
```
    Specified by:
    
    join in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
    
    See Also:
    
    SelectJoinStep.join(Expression)
  - join
```
public final SelectImpl join(Expression name)
```
    Specified by:
    
    join in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
  - innerJoin
```
public final SelectImpl innerJoin(java.lang.String name)
```
    Specified by:
    
    innerJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
    
    See Also:
    
    SelectJoinStep.innerJoin(Expression)
  - innerJoin
```
public final SelectImpl innerJoin(Expression name)
```
    Specified by:
    
    innerJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
  - leftJoin
```
public final SelectImpl leftJoin(java.lang.String name)
```
    Specified by:
    
    leftJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
    
    See Also:
    
    SelectJoinStep.leftJoin(Expression)
  - leftJoin
```
public final SelectImpl leftJoin(Expression name)
```
    Specified by:
    
    leftJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
  - rightJoin
```
public final SelectImpl rightJoin(java.lang.String name)
```
    Specified by:
    
    rightJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
    
    See Also:
    
    SelectJoinStep.rightJoin(Expression)
  - rightJoin
```
public final SelectImpl rightJoin(Expression name)
```
    Specified by:
    
    rightJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
  - fullJoin
```
public final SelectImpl fullJoin(java.lang.String name)
```
    Specified by:
    
    fullJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
    
    See Also:
    
    SelectJoinStep.fullJoin(Expression)
  - fullJoin
```
public final SelectImpl fullJoin(Expression name)
```
    Specified by:
    
    fullJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
  - crossJoin
```
public final SelectImpl crossJoin(java.lang.String name)
```
    Specified by:
    
    crossJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
    
    See Also:
    
    SelectJoinStep.crossJoin(Expression)
  - crossJoin
```
public final SelectImpl crossJoin(Expression name)
```
    Specified by:
    
    crossJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
  - naturalJoin
```
public final SelectImpl naturalJoin(java.lang.String name)
```
    Specified by:
    
    naturalJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
    
    See Also:
    
    SelectJoinStep.naturalJoin(Expression)
  - naturalJoin
```
public final SelectImpl naturalJoin(Expression name)
```
    Specified by:
    
    naturalJoin in interface SelectJoinStep
    
    Parameters:
    
    name - is a table name. actually it can be ROW, or VALUES expression
  - using
```
public final SelectImpl using(java.lang.String... name)
```
    Description copied from interface: SelectJoinOnFirstStep
    
    Example: // SELECT * FROM book JOIN author USING (id) select("*") .from("book") .join("author") .using("id") .sql()
    
    Specified by:
    
    using in interface SelectJoinOnFirstStep
  - using
```
public final SelectImpl using(Expression... columns)
```
    Description copied from interface: SelectJoinOnFirstStep
    
    Example: // SELECT * FROM book JOIN author USING (id) select("*") .from(asName("book")) .join("author") .using(asName("id")) .sql()
    
    Specified by:
    
    using in interface SelectJoinOnFirstStep
  - on
```
public final SelectImpl on(boolean conditions)
```
    Description copied from interface: SelectJoinOnFirstStep
    
    This form of JOIN ON condition is equivalent to CROSS JOIN. Example: // SELECT * FROM book AS b JOIN author a ON (true) select("*") .from(asName("book").as("b")) .join("author a") .on(true) .sql()
    
    Specified by:
    
    on in interface SelectJoinOnFirstStep
  - on
```
public final <T> SelectImpl on(T left,
                               T operator,
                               T right)
```
    Description copied from interface: SelectJoinOnFirstStep
    
    Example: // SELECT * FROM book AS b JOIN author a ON a.id = b.author_id select("*") .from(asName("book").as("b")) .join("author a") .on("a.id", "=", "b.author_id") .sql()
    
    Specified by:
    
    on in interface SelectJoinOnFirstStep
    
    Type Parameters:
    
    T - String, Expression, Operator or Query object
    
    Parameters:
    
    left - left operand
    
    operator - operator
    
    right - right operand
  - on
```
public final SelectImpl on(Conditions conditions)
```
    Specified by:
    
    on in interface SelectJoinOnFirstStep
  - onExists
```
public final SelectImpl onExists(Query query)
```
    Specified by:
    
    onExists in interface SelectJoinOnFirstStep
  - union
```
public final SelectImpl union(SelectFinalStep select)
```
    Description copied from interface: SelectCombiningQueryStep
    
    Combine main query with select query using UNION.
    
    Specified by:
    
    union in interface SelectCombiningQueryStep
  - unionAll
```
public final SelectImpl unionAll(SelectFinalStep select)
```
    Description copied from interface: SelectCombiningQueryStep
    
    Combine main query with select query using UNION ALL.
    
    Specified by:
    
    unionAll in interface SelectCombiningQueryStep
  - intersect
```
public final SelectImpl intersect(SelectFinalStep select)
```
    Description copied from interface: SelectCombiningQueryStep
    
    Combine main query with select query using INTERSECT.
    
    Specified by:
    
    intersect in interface SelectCombiningQueryStep
  - intersectAll
```
public final SelectImpl intersectAll(SelectFinalStep select)
```
    Description copied from interface: SelectCombiningQueryStep
    
    Combine main query with select query using INTERSECT ALL.
    
    Specified by:
    
    intersectAll in interface SelectCombiningQueryStep
  - except
```
public final SelectImpl except(SelectFinalStep select)
```
    Description copied from interface: SelectCombiningQueryStep
    
    Combine main query with select query using EXCEPT.
    
    Specified by:
    
    except in interface SelectCombiningQueryStep
  - exceptAll
```
public final SelectImpl exceptAll(SelectFinalStep select)
```
    Description copied from interface: SelectCombiningQueryStep
    
    Combine main query with select query using EXCEPT ALL.
    
    Specified by:
    
    exceptAll in interface SelectCombiningQueryStep
  - having
```
public final <T> SelectImpl having(T left,
                                   T operator,
                                   T right)
```
    Description copied from interface: SelectHavingFirstStep
    
    Example: // SELECT year FROM book HAVING year > 2010 select("year", "id") .from("book") .having("year", ">", "2010") .sql()
    
    Specified by:
    
    having in interface SelectHavingFirstStep
    
    Type Parameters:
    
    T - String, Expression, Operator or Query object
    
    Parameters:
    
    left - left operand
    
    operator - operator
    
    right - right operand
  - having
```
public final SelectImpl having(Conditions conditions)
```
    Description copied from interface: SelectHavingFirstStep
    This function useful in a few case:
    - When the conditions is a special case of condition, like Queryman.conditionBetween(Object, Object, Object), or Queryman.conditionSome(Object, Object, Query) etc. See the first example.
    - When the conditions is a group of conditions are joined by AND, AND NOT, OR and OR NOT operators. These conditions are being a grouped condition, and will be surrounded by parentheses. See the second example.
    The first example: // SELECT id FROM book HAVING id BETWEEN 1 AND 10 select("id") .from("book") .having(conditionBetween("id", "1", "10")) .sql() The second example: // SELECT id, name FROM book HAVING (id BETWEEN 1 AND 10 AND name = 'Advanced SQL') select("id", "name") .from("book") .having( conditionBetween("id", "1", "10") .and(asName("name"), operator("="), asString("Advanced SQL")) ) .sql()
    Specified by:
    
    having in interface SelectHavingFirstStep
    
    Parameters:
    
    conditions - condition
    
    Returns:
    
    itself Kind of conditions:
    
    See Also:
    
    Queryman.condition(Object, Object, Object)
  - havingExists
```
public final SelectImpl havingExists(Query query)
```
    Description copied from interface: SelectHavingFirstStep
    
    Example: // SELECT * FROM book HAVING EXISTS (SELECT * FROM author) select("*") .from("book") .havingExists(select("*").from("authors")) .sql()
    
    Specified by:
    
    havingExists in interface SelectHavingFirstStep
    
    Parameters:
    
    query - subquery
    
    Returns:
    
    itself
  - forUpdate
```
public final SelectImpl forUpdate()
```
    Description copied from interface: SelectLockingStep
    
    Specifies a locking mode name FOR UPDATE.
    
    Specified by:
    
    forUpdate in interface SelectLockingStep
    
    Returns:
    
    a step to specify locking table or tables
  - forNoKeyUpdate
```
public final SelectImpl forNoKeyUpdate()
```
    Description copied from interface: SelectLockingStep
    
    Specifies a locking mode name FOR NO KEY UPDATE.
    
    Specified by:
    
    forNoKeyUpdate in interface SelectLockingStep
    
    Returns:
    
    a step to specify locking table or tables
  - forShare
```
public final SelectImpl forShare()
```
    Description copied from interface: SelectLockingStep
    
    Specifies a locking mode name FOR SHARE.
    
    Specified by:
    
    forShare in interface SelectLockingStep
    
    Returns:
    
    a step to specify locking table or tables
  - forKeyShare
```
public final SelectImpl forKeyShare()
```
    Description copied from interface: SelectLockingStep
    
    Specifies a locking mode name FOR KEY SHARE.
    
    Specified by:
    
    forKeyShare in interface SelectLockingStep
    
    Returns:
    
    a step to specify locking table or tables
  - of
```
public final SelectImpl of(java.lang.String... tables)
```
    Description copied from interface: SelectLockingOfTableStep
    
    Specifies tables, rows of those are locking.
    
    Specified by:
    
    of in interface SelectLockingOfTableStep
    
    Parameters:
    
    tables - list of tables
    
    Returns:
    
    a step to specify waiting mode
    
    See Also:
    
    SelectLockingOfTableStep.of(Expression...)
  - of
```
public final SelectImpl of(Expression... tables)
```
    Description copied from interface: SelectLockingOfTableStep
    
    Specifies tables, rows of those are locking.
    
    Specified by:
    
    of in interface SelectLockingOfTableStep
    
    Parameters:
    
    tables - list of tables
    
    Returns:
    
    a step to specify waiting mode
  - skipLocked
```
public final SelectImpl skipLocked()
```
    Description copied from interface: SelectLockingWaitingStep
    
    Specifies SKIP LOCKED mode, meaning the SELECT statement will omit the locked rows.
    
    Specified by:
    
    skipLocked in interface SelectLockingWaitingStep
    
    Returns:
    
    select final step
  - noWait
```
public final SelectImpl noWait()
```
    Description copied from interface: SelectLockingWaitingStep
    
    Specifies NOWAIT mode, meaning the SELECT statement will report an error, if rows are locked, rather than will wait for rows.
    
    Specified by:
    
    noWait in interface SelectLockingWaitingStep
    
    Returns:
    
    select final step

Class SelectImpl

Constructor Summary

Method Summary

Methods inherited from class org.queryman.builder.AbstractQuery

Methods inherited from class java.lang.Object

Methods inherited from interface org.queryman.builder.Query

Constructor Detail

SelectImpl

SelectImpl

SelectImpl

Method Detail

all

distinct

distinctOn

distinctOn

assemble

from

from

from

where

where

whereExists

and

and

andExists

andNot

andNot

andNotExists

or

or

orExists

orNot

orNot

orNotExists

groupBy

groupBy

orderBy

orderBy

orderBy

orderBy

limit

limit

offset

offset

join

join

innerJoin

innerJoin

leftJoin

leftJoin

rightJoin

rightJoin

fullJoin

fullJoin

crossJoin

crossJoin

naturalJoin

naturalJoin

using

using

on

on

on

onExists

union

unionAll

intersect

intersectAll

except

exceptAll

having

having

havingExists

forUpdate

forNoKeyUpdate

forShare

forKeyShare

of

of

skipLocked