Queryman (queryman-builder API)

java.lang.Object
- org.queryman.builder.Queryman

```
public class Queryman
extends java.lang.Object
```
The entry point to all parts of PostgreSQL clauses. This contains a full collection of SQL statements like the SELECT, UPDATE, DELETE etc. Also other parts of SQL clauses are encapsulated here, such as conditions clause (AND, OR, OR NOT, etc), FROM clause, etc.

Constructor Summary

Constructors
Constructor Description

Queryman()

Constructors
Constructor	Description
`Queryman()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static <T> Expression`	`all(T argument)`	Creates an ALL expression that contains one argument
`static <T> Expression`	`all(T... arguments)`	Creates an ALL expression that contains one argument
`static <T> Expression`	`any(T argument)`	Creates an ANY expression that contains one argument
`static <T> Expression`	`any(T... arguments)`	Creates an ANY expression that contains one argument
`static <T> Expression`	`asArray(java.util.Collection<T> arr)`	Array expression: `asArray(List.of(1,2)); // ARRAY[1, 2]`
`static <T> Expression`	`asArray(T... arr)`	Array expression: `asArray(1, 2); // ARRAY[1, 2]`
`static <T> Expression`	`asConstant(T constant)`	Using a class name of constant it creates an appropriate Expression object.
`static <T> Expression`	`asConstant(T[] constants)`	Creates an array expression.
`static <T> Expression`	`asDate(T date)`	Creates a Date expression.
`static Expression`	`asDollarString(java.lang.String constant)`	Dollar string expression: `$$any string is here$$`
`static Expression`	`asDollarString(java.lang.String constant, java.lang.String tagName)`	Dollar string expression: `$$any string is here$$ $tag$any string is here$tag$`
`static Expression`	`asFunc(java.lang.String name, Expression expression)`	Examples: `asFunc("ALL", asArray(List.of(1, 2))); // ALL(ARRAY[1, 2]) asFunc("SOME", asList(1, 2)); // SOME(1, 2)`
`static <T> Expression`	`asFunc(java.lang.String name, T... arguments)`
`static <T> Expression`	`asList(java.util.Collection<T> constants)`	List expression.
`static <T> Expression`	`asList(T... constants)`	List expression.
`static Expression`	`asName(java.lang.String constant)`	Column reference expression: `table.column (complex_type).field`
`static Expression`	`asOperator(java.lang.String name, Expression expression)`	This is a synonym of `asFunc(String, Expression)`.
`static <T> Expression`	`asOperator(java.lang.String name, T... arguments)`	This is a synonym of `asFunc(String, Object[])`.
`static Expression`	`asQuotedName(java.lang.String constant)`	Quoted column reference expression: `"table"."column"`
`static Expression`	`asSubQuery(Query query)`
`static <T> Expression`	`asTime(T time)`	Creates a Time expression.
`static <T> Expression`	`asTimestamp(T timestamp)`	Creates a Timestamp expression.
`static <T> Conditions`	`condition(T leftValue, T operator, T rightValue)`	Creates a condition `...`
`static <T> Conditions`	`conditionAll(T field, T operator, Query query)`	Creates a condition.
`static <T> Conditions`	`conditionAny(T field, T operator, Query query)`	Create a condition.
`static <F,T> Conditions`	`conditionBetween(F field, T value1, T value2)`	Creates a BETWEEN condition `...`
`static Conditions`	`conditionExists(Query query)`	Creates a condition.
`static <T> Conditions`	`conditionSome(T field, T operator, Query query)`	Creates a condition.
`static SequenceAsStep`	`createSequence(java.lang.String name)`	Creates a sequence.
`static SequenceAsStep`	`createSequence(Expression name)`	Creates a sequence.
`static SequenceAsStep`	`createSequenceIfNotExists(java.lang.String name)`	Creates a sequence.
`static SequenceAsStep`	`createSequenceIfNotExists(Expression name)`	Creates a sequence.
`static SequenceAsStep`	`createTempSequence(java.lang.String name)`	Creates a create_sequence.
`static SequenceAsStep`	`createTempSequence(Expression name)`	Creates a sequence.
`static SequenceAsStep`	`createTempSequenceIfNotExists(java.lang.String name)`	Creates a sequence.
`static SequenceAsStep`	`createTempSequenceIfNotExists(Expression name)`	Creates a sequence.
`static void`	`declare(java.lang.String name)`
`static DeleteAsStep`	`deleteFrom(java.lang.String name)`	DELETE statement.
`static DeleteAsStep`	`deleteFrom(Expression name)`	DELETE statement.
`static DeleteAsStep`	`deleteFromOnly(java.lang.String name)`	DELETE statement.
`static DeleteAsStep`	`deleteFromOnly(Expression name)`	DELETE statement.
`static FromFirstStep`	`from(java.lang.String tableName)`	FROM clause can be used as a part of other SQL statements.
`static FromFirstStep`	`from(Expression tableName)`	FROM clause can be used as a part of other SQL statements.
`static FromFirstStep`	`fromOnly(java.lang.String tableName)`	FROM clause can be used as a part of other SQL statements.
`static FromFirstStep`	`fromOnly(Expression tableName)`	FROM clause can be used as a part of other SQL statements.
`static AbstractSyntaxTree`	`getTree()`
`static InsertAsStep`	`insertInto(java.lang.String table)`	INSERT INTO statement.
`static InsertAsStep`	`insertInto(Expression table)`	INSERT INTO statement.
`static Keyword`	`keyword(java.lang.String keyword)`	Creates a keyword which ordinarily is used to build SQL query.
`static Expression`	`max(java.lang.String field)`	Examples: `max("price"); // MAX("price")`
`static NodeMetadata`	`nodeMetadata(Keyword keyword)`	NodeMetadata contains a metadata for tree node.
`static <T> Operator`	`operator(T operator)`	Creates an operator which ordinarily is used by condition.
`static OrderBy`	`orderBy(java.lang.String name)`	Creates an `OrderBy` object.
`static OrderBy`	`orderBy(java.lang.String name, java.lang.String sorting)`	Creates an `OrderBy` object.
`static OrderBy`	`orderBy(java.lang.String name, java.lang.String sorting, java.lang.String nulls)`	Creates an `OrderBy` object.
`static SelectFromStep`	`select(Expression... columns)`	SELECT statement.
`static <T> SelectFromStep`	`select(T... columns)`	SELECT statement.
`static SelectFromStep`	`selectAll(Expression... columns)`	SELECT ALL statement.
`static <T> SelectFromStep`	`selectAll(T... columns)`	SELECT ALL statement.
`static SelectFromStep`	`selectDistinct(Expression... columns)`	SELECT DISTINCT statement.
`static <T> SelectFromStep`	`selectDistinct(T... columns)`	SELECT DISTINCT statement.
`static <T> SelectFromStep`	`selectDistinctOn(java.lang.String[] distinct, T... columns)`	SELECT DISTINCT ON (..) ..
`static SelectFromStep`	`selectDistinctOn(Expression[] distinct, Expression... columns)`	SELECT DISTINCT ON (..) ..
`static void`	`setTreeFactory(TreeFactory factory)`	Sets a `TreeFactory` explicitly, otherwise it is set implicitly via the static block above.
`static <T> Expression`	`some(T argument)`	Creates an SOME expression that contains one argument
`static <T> Expression`	`some(T... arguments)`	Creates an SOME expression that contains one argument
`static ConflictTarget`	`targetColumn(java.lang.String column)`	The type represents an index column.
`static ConflictTarget`	`targetColumn(java.lang.String column, java.lang.String collation)`	The type represents an index column.
`static ConflictTarget`	`targetColumn(java.lang.String column, java.lang.String collation, java.lang.String opclass)`	The type represents an index column.
`static ConflictTarget`	`targetExpression(java.lang.String expression)`	The type represents an index expression.
`static ConflictTarget`	`targetExpression(java.lang.String expression, java.lang.String collation)`	The type represents an index expression.
`static ConflictTarget`	`targetExpression(java.lang.String expression, java.lang.String collation, java.lang.String opclass)`	The type represents an index expression.
`static UpdateAsStep`	`update(java.lang.String name)`	UPDATE statement.
`static UpdateAsStep`	`update(Expression name)`	UPDATE statement.
`static UpdateAsStep`	`updateOnly(java.lang.String name)`	UPDATE statement.
`static UpdateAsStep`	`updateOnly(Expression name)`	UPDATE statement.
`static <T> Expression`	`values(T... expressions)`	VALUES list.
`static WithAsStep`	`with(java.lang.String name, java.lang.String... columns)`	Starts WITH ...
`static WithAsStep`	`withRecursive(java.lang.String name, java.lang.String... columns)`	Starts WITH RECURSIVE statement

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

- Constructor Detail
  - Queryman
```
public Queryman()
```
- Method Detail
  - setTreeFactory
```
public static void setTreeFactory(TreeFactory factory)
```
    Sets a TreeFactory explicitly, otherwise it is set implicitly via the static block above.
    
    Parameters:
    
    factory - tree factory
  - getTree
```
public static AbstractSyntaxTree getTree()
```
    Returns:
    
    an abstract syntax three
  - with
```
public static WithAsStep with(java.lang.String name,
                              java.lang.String... columns)
```
    Starts WITH ... statement
    
    Parameters:
    
    name - name of with query
    
    columns - output columns
    
    Returns:
    
    with column step
  - withRecursive
```
public static WithAsStep withRecursive(java.lang.String name,
                                       java.lang.String... columns)
```
    Starts WITH RECURSIVE statement
    
    Parameters:
    
    name - name of with query
    
    columns - output columns
    
    Returns:
    
    with column step
  - select
```
@SafeVarargs
public static <T> SelectFromStep select(T... columns)
```
    SELECT statement. Example: select("id", "name", 3); // SELECT id, name, 3
    
    Parameters:
    
    columns - output columns
    
    Returns:
    
    select from step
  - select
```
public static SelectFromStep select(Expression... columns)
```
    SELECT statement. Example: select(asName("id"), asName("name")); // SELECT id, name
    
    Parameters:
    
    columns - output columns
    
    Returns:
    
    select from step
  - selectAll
```
@SafeVarargs
public static <T> SelectFromStep selectAll(T... columns)
```
    SELECT ALL statement. Example: selectAll("id", "name"); // SELECT ALL id, name
    
    Parameters:
    
    columns - output columns
    
    Returns:
    
    select from step
  - selectAll
```
public static SelectFromStep selectAll(Expression... columns)
```
    SELECT ALL statement. Example: select(asName("id"), asName("name")); // SELECT id, name
    
    Parameters:
    
    columns - output columns
    
    Returns:
    
    select from step
  - selectDistinct
```
@SafeVarargs
public static <T> SelectFromStep selectDistinct(T... columns)
```
    SELECT DISTINCT statement. Example: selectDistinct("id", "name"); // SELECT DISTINCT id, name
    
    Parameters:
    
    columns - output columns
    
    Returns:
    
    select from step
  - selectDistinct
```
public static SelectFromStep selectDistinct(Expression... columns)
```
    SELECT DISTINCT statement. Example: selectDistinct(asName("id"), asName("name")); // SELECT DISTINCT id, name
    
    Parameters:
    
    columns - output columns
    
    Returns:
    
    select from step
  - selectDistinctOn
```
@SafeVarargs
public static <T> SelectFromStep selectDistinctOn(java.lang.String[] distinct,
                                                  T... columns)
```
    SELECT DISTINCT ON (..) .. statement. Example: String[] distinct = {"id"}; selectDistinctOn(distinct, "id", "name"); // SELECT DISTINCT ON (id) id, name
    
    Parameters:
    
    columns - output columns
    
    Returns:
    
    select from step
  - selectDistinctOn
```
public static SelectFromStep selectDistinctOn(Expression[] distinct,
                                              Expression... columns)
```
    SELECT DISTINCT ON (..) .. statement. Example: Expression[] distinct = {"id"}; selectDistinctOn(distinct, asName("id"), asName("name")); // SELECT DISTINCT ON (id) id, name
    
    Parameters:
    
    columns - output columns
    
    Returns:
    
    select from step
  - createSequence
```
public static SequenceAsStep createSequence(java.lang.String name)
```
    Creates a sequence. Example: createSequence("book_seq") .as("smallint") .incrementBy(1) .minvalue(0) .noMaxvalue() .startWith(0) .cache(5) .cycle() .ownedByNone() .sql();
    
    Parameters:
    
    name - sequence name
    
    Returns:
    
    sequence AS step
  - createSequence
```
public static SequenceAsStep createSequence(Expression name)
```
    Creates a sequence. Example: createSequence(asName("book_seq")) .as("smallint") .incrementBy(1) .minvalue(0) .noMaxvalue() .startWith(0) .cache(5) .cycle() .ownedByNone() .sql();
    
    Parameters:
    
    name - sequence name
    
    Returns:
    
    sequence AS step
  - createTempSequence
```
public static SequenceAsStep createTempSequence(java.lang.String name)
```
    Creates a create_sequence. Example: createTempSequence("book_seq") .as("smallint") .incrementBy(1) .minvalue(0) .noMaxvalue() .startWith(0) .cache(5) .cycle() .ownedByNone() .sql();
    
    Parameters:
    
    name - sequence name
    
    Returns:
    
    sequence AS step
  - createTempSequence
```
public static SequenceAsStep createTempSequence(Expression name)
```
    Creates a sequence. Example: createTempSequence(asName("book_seq")) .as("smallint") .incrementBy(1) .minvalue(0) .noMaxvalue() .startWith(0) .cache(5) .cycle() .ownedByNone() .sql();
    
    Parameters:
    
    name - sequence name
    
    Returns:
    
    sequence AS step
  - createTempSequenceIfNotExists
```
public static SequenceAsStep createTempSequenceIfNotExists(java.lang.String name)
```
    Creates a sequence. Example: createTempSequenceIfNotExists("book_seq") .as("smallint") .incrementBy(1) .minvalue(0) .noMaxvalue() .startWith(0) .cache(5) .cycle() .ownedByNone() .sql();
    
    Parameters:
    
    name - sequence name
    
    Returns:
    
    sequence AS step
  - createTempSequenceIfNotExists
```
public static SequenceAsStep createTempSequenceIfNotExists(Expression name)
```
    Creates a sequence. Example: createTempSequenceIfNotExists(asName("book_seq")) .as("smallint") .incrementBy(1) .minvalue(0) .noMaxvalue() .startWith(0) .cache(5) .cycle() .ownedByNone() .sql();
    
    Parameters:
    
    name - sequence name
    
    Returns:
    
    sequence AS step
  - createSequenceIfNotExists
```
public static SequenceAsStep createSequenceIfNotExists(java.lang.String name)
```
    Creates a sequence. Example: createSequenceIfNotExists("book_seq") .as("smallint") .incrementBy(1) .minvalue(0) .noMaxvalue() .startWith(0) .cache(5) .cycle() .ownedByNone() .sql();
    
    Parameters:
    
    name - sequence name
    
    Returns:
    
    sequence AS step
  - createSequenceIfNotExists
```
public static SequenceAsStep createSequenceIfNotExists(Expression name)
```
    Creates a sequence. Example: createSequenceIfNotExists(asName("book_seq")) .as("smallint") .incrementBy(1) .minvalue(0) .noMaxvalue() .startWith(0) .cache(5) .cycle() .ownedByNone() .sql();
    
    Parameters:
    
    name - sequence name
    
    Returns:
    
    sequence AS step
  - declare
```
public static void declare(java.lang.String name)
```
  - deleteFrom
```
public static DeleteAsStep deleteFrom(java.lang.String name)
```
    DELETE statement. // DELETE FROM book AS b USING author, order WHERE b.id = 1 RETURNING id deleteFrom("book") .as("b") .using("author", "order") .where("b.id", "=", "1") .returning(asName("id") .sql()
    
    Parameters:
    
    name - target table name
    
    Returns:
    
    delete AS step
  - deleteFrom
```
public static DeleteAsStep deleteFrom(Expression name)
```
    DELETE statement. // DELETE FROM book AS b USING author, order WHERE b.id = 1 RETURNING id deleteFrom(asName("book")) .as("b") .using("author", "order") .where("b.id", "=", "1") .returning(asName("id") .sql()
    
    Parameters:
    
    name - target table name
    
    Returns:
    
    delete AS step
  - deleteFromOnly
```
public static DeleteAsStep deleteFromOnly(java.lang.String name)
```
    DELETE statement. // DELETE FROM ONLY book AS b USING author, order WHERE b.id = 1 RETURNING id deleteFromOnly("book") .as("b") .using("author", "order") .where("b.id", "=", "1") .returning(asName("id") .sql()
    
    Parameters:
    
    name - target table name
    
    Returns:
    
    delete AS step
  - deleteFromOnly
```
public static DeleteAsStep deleteFromOnly(Expression name)
```
    DELETE statement. // DELETE FROM ONLY book AS b USING author, order WHERE b.id = 1 RETURNING id deleteFromOnly(asName("book")) .as("b") .using("author", "order") .where("b.id", "=", "1") .returning(asName("id") .sql()
    
    Parameters:
    
    name - target table name
    
    Returns:
    
    delete AS step
  - update
```
public static UpdateAsStep update(java.lang.String name)
```
    UPDATE statement.
```
     // UPDATE book AS b SET author = 'Andrew' WHERE b.id = 1 RETURNING max(price) AS price
     update("book")
      .as("b")
      .set("author", asConstant("Andrew"))
      .where("b.id", "=", 1)
      .returning(asName("max(price)").as("price"))
      .sql();
 
```
    Parameters:
    
    name - name of the table ot update
    
    Returns:
    
    update as step
  - update
```
public static UpdateAsStep update(Expression name)
```
    UPDATE statement. // UPDATE book AS b SET author = 'Andrew' WHERE b.id = 1 RETURNING max(price) AS price update(asName("book")) .as("b") .set("author", asConstant("Andrew")) .where("b.id", "=", 1) .returning(asName("max(price)").as("price")) .sql();
    
    Parameters:
    
    name - name of the table ot update
    
    Returns:
    
    update as step
  - updateOnly
```
public static UpdateAsStep updateOnly(java.lang.String name)
```
    UPDATE statement. // UPDATE ONLY book AS b SET author = 'Andrew' WHERE b.id = 1 RETURNING max(price) AS price updateOnly("book") .as("b") .set("author", asConstant("Andrew")) .where("b.id", "=", 1) .returning(asName("max(price)").as("price")) .sql();
    
    Parameters:
    
    name - name of the table ot update
    
    Returns:
    
    update as step
  - updateOnly
```
public static UpdateAsStep updateOnly(Expression name)
```
    UPDATE statement. // UPDATE ONLY book AS b SET author = 'Andrew' WHERE b.id = 1 RETURNING max(price) AS price updateOnly(asName("book")) .as("b") .set("author", asConstant("Andrew")) .where("b.id", "=", 1) .returning(asName("max(price)").as("price")) .sql();
    
    Parameters:
    
    name - name of the table ot update
    
    Returns:
    
    update as step
  - insertInto
```
public static InsertAsStep insertInto(java.lang.String table)
```
    INSERT INTO statement. insertInto("book") .as("b") .columns("id", "name") .overridingSystemValue() .values(1, "test") .onConflict() .onConstraint("index_name") .doNothing() .sql()
    
    Parameters:
    
    table - target table name
    
    Returns:
    
    insert AS step
  - insertInto
```
public static InsertAsStep insertInto(Expression table)
```
    INSERT INTO statement. insertInto(asName("book")) .as("b") .columns("id", "name") .overridingSystemValue() .values(1, "test") .onConflict() .onConstraint("index_name") .doNothing() .sql()
    
    Parameters:
    
    table - target table name
    
    Returns:
    
    insert AS step
  - condition
```
public static <T> Conditions condition(T leftValue,
                                       T operator,
                                       T rightValue)
```
    Creates a condition ... .where(condition("id", "=", "author_id")) ...
    
    Type Parameters:
    
    T - Any primitive or its wrapper, Expression, Operator or Query object
    
    Parameters:
    
    leftValue - left operand, it may by any primitive or its wrapper.
    
    operator - operator, String or Operator object
    
    rightValue - right operand, it may by any primitive or its wrapper.
    
    Returns:
    
    Conditions
  - conditionBetween
```
public static <F,T> Conditions conditionBetween(F field,
                                                T value1,
                                                T value2)
```
    Creates a BETWEEN condition ... .where(conditionBetween("id", "2", "10")) ...
    
    Type Parameters:
    
    T - any primitive or its wrapper ot Expression
    
    F - String or Expression
    
    Parameters:
    
    field - field
    
    value1 - left value of AND
    
    value2 - right value of AND
    
    Returns:
    
    Conditions
  - conditionExists
```
public static Conditions conditionExists(Query query)
```
    Creates a condition. conditionExists(select(1, 2)); // EXISTS (SELECT 1, 2);
    
    Parameters:
    
    query - subquery
    
    Returns:
    
    Conditions
  - conditionSome
```
public static <T> Conditions conditionSome(T field,
                                           T operator,
                                           Query query)
```
    Creates a condition. Example: conditionSome("id", "=", select(1)); // id = SOME (SELECT 1);
    
    Parameters:
    
    field - left operand
    
    operator - operator
    
    query - subquery right operand
    
    Returns:
    
    Conditions
  - conditionAny
```
public static <T> Conditions conditionAny(T field,
                                          T operator,
                                          Query query)
```
    Create a condition. Example: conditionAny("id", "=", select(1, 2)); // id = ANY (SELECT 1, 2);
    
    Parameters:
    
    field - left operand
    
    operator - operator
    
    query - subquery right operand
    
    Returns:
    
    Conditions
  - conditionAll
```
public static <T> Conditions conditionAll(T field,
                                          T operator,
                                          Query query)
```
    Creates a condition. Example: conditionAll("id", "=", select(1, 2)); // id = ALL (SELECT 1, 2);
    
    Parameters:
    
    field - left operand
    
    operator - operator
    
    query - subquery -right operand
    
    Returns:
    
    Conditions
  - from
```
public static FromFirstStep from(java.lang.String tableName)
```
    FROM clause can be used as a part of other SQL statements. from("book") .as(b) .tablesample("BERNOULLI", "1") .repeatable(1)
    
    Parameters:
    
    tableName - is a table name.
    
    Returns:
    
    first step of FROM clause.
    
    See Also:
    
    from(Expression)
  - from
```
public static FromFirstStep from(Expression tableName)
```
    FROM clause can be used as a part of other SQL statements. from(asName("book")) .as(b) .tablesample("BERNOULLI", "1") .repeatable(1)
    
    Parameters:
    
    tableName - is a table name.
    
    Returns:
    
    first step of FROM clause.
    
    See Also:
    
    from(Expression)
  - fromOnly
```
public static FromFirstStep fromOnly(java.lang.String tableName)
```
    FROM clause can be used as a part of other SQL statements. fromOnly("book") .as(b) .tablesample("BERNOULLI", "1") .repeatable(1)
    
    Parameters:
    
    tableName - is a table name.
    
    Returns:
    
    first step of FROM clause.
    
    See Also:
    
    fromOnly(Expression)
  - fromOnly
```
public static FromFirstStep fromOnly(Expression tableName)
```
    FROM clause can be used as a part of other SQL statements. from(asName("book")) .as(b) .tablesample("BERNOULLI", "1") .repeatable(1)
    
    Parameters:
    
    tableName - is a table name.
    
    Returns:
    
    first step of FROM clause.
  - asConstant
```
public static <T> Expression asConstant(T constant)
```
    Using a class name of constant it creates an appropriate Expression object. Date is could not be convert to particular expression, you should use ad hoc methods to convert it to any expression of DATE type: * asDate(Object) * asTime(Object) * asTimestamp(Object)
    
    Parameters:
    
    constant - any constant
    
    Returns:
    
    a constant of appropriate type.
    
    Throws:
    
    java.lang.IllegalArgumentException - if constant is not supported
    
    See Also:
    
    PostgreSQL constants
  - asConstant
```
public static <T> Expression asConstant(T[] constants)
```
    Creates an array expression. If constant if Byte[] type, the ByteExpression is created.
    
    Parameters:
    
    constants - array constant
    
    Returns:
    
    array expression
    
    See Also:
    
    asConstant(Object)
  - asDate
```
public static <T> Expression asDate(T date)
```
    Creates a Date expression.
    
    Parameters:
    
    date - date
    
    Returns:
    
    DateExpression
  - asTime
```
public static <T> Expression asTime(T time)
```
    Creates a Time expression.
    
    Parameters:
    
    time - time
    
    Returns:
    
    TimeExpression
  - asTimestamp
```
public static <T> Expression asTimestamp(T timestamp)
```
    Creates a Timestamp expression.
    
    Parameters:
    
    timestamp - time
    
    Returns:
    
    TimestampExpression
  - asDollarString
```
public static Expression asDollarString(java.lang.String constant)
```
    Dollar string expression: $$any string is here$$
    
    Parameters:
    
    constant - dollar string
    
    Returns:
    
    a string surrounded by dollar singes string. e.g. $$string$$
  - asDollarString
```
public static Expression asDollarString(java.lang.String constant,
                                        java.lang.String tagName)
```
    Dollar string expression: $$any string is here$$ $tag$any string is here$tag$
    
    Parameters:
    
    constant - dollar string
    
    tagName - tag name
    
    Returns:
    
    a string surrounded by dollar singes string. e.g. $tag$ string $tag$
  - asName
```
public static Expression asName(java.lang.String constant)
```
    Column reference expression: table.column (complex_type).field
    
    Parameters:
    
    constant - column reference string
    
    Returns:
    
    a quoted name. e.g. id; table.phone
  - asQuotedName
```
public static Expression asQuotedName(java.lang.String constant)
```
    Quoted column reference expression: "table"."column"
    
    Parameters:
    
    constant - column reference string
    
    Returns:
    
    a quoted name. e.g. "id"; "table"."phone"
  - asList
```
@SafeVarargs
public static <T> Expression asList(T... constants)
```
    List expression. Example: asString(1, 2, 3); // (1, 2, 3)
    
    Parameters:
    
    constants - values
    
    Returns:
    
    (...), where ... are values concatenated by comma.
  - asList
```
public static <T> Expression asList(java.util.Collection<T> constants)
```
    List expression. Example: asString(List.of(1, 2, 3)); // (1, 2, 3)
    
    Parameters:
    
    constants - values
    
    Returns:
    
    (...), where ... are values concatenated by comma.
  - asArray
```
@SafeVarargs
public static <T> Expression asArray(T... arr)
```
    Array expression: asArray(1, 2); // ARRAY[1, 2]
    
    Parameters:
    
    arr - - values of array
    
    Returns:
    
    ARRAY[...], where ... are values concatenated by comma.
  - asArray
```
public static <T> Expression asArray(java.util.Collection<T> arr)
```
    Array expression: asArray(List.of(1,2)); // ARRAY[1, 2]
    
    Parameters:
    
    arr - - values of array
    
    Returns:
    
    ARRAY[...], where ... are values concatenated by comma.
  - asFunc
```
public static Expression asFunc(java.lang.String name,
                                Expression expression)
```
    Examples: asFunc("ALL", asArray(List.of(1, 2))); // ALL(ARRAY[1, 2]) asFunc("SOME", asList(1, 2)); // SOME(1, 2)
    
    Parameters:
    
    name - - function or operator name, examples: ALL, ANY ...
    
    expression - - list or array expression
    
    Returns:
    
    a combine of name and expression objects
    
    See Also:
    
    asArray(Object[]), asList(Object[])
  - asFunc
```
@SafeVarargs
public static <T> Expression asFunc(java.lang.String name,
                                    T... arguments)
```
    Parameters:
    
    name - of function
    
    arguments - arguments
    
    Returns:
    
    a function with list of arguments
    
    See Also:
    
    asFunc(String, Expression)
  - max
```
public static Expression max(java.lang.String field)
```
    Examples: max("price"); // MAX("price")
    
    Parameters:
    
    field - field
    
    Returns:
    
    an aggregate functions
  - all
```
public static <T> Expression all(T argument)
```
    Creates an ALL expression that contains one argument
    
    Type Parameters:
    
    T - String ot Expression object
    
    Parameters:
    
    argument - argument of any
    
    Returns:
    
    an ALL expression
  - all
```
@SafeVarargs
public static <T> Expression all(T... arguments)
```
    Creates an ALL expression that contains one argument
    
    Type Parameters:
    
    T - String ot Expression objects
    
    Parameters:
    
    arguments - argument of
    
    Returns:
    
    an ALL expression
  - any
```
public static <T> Expression any(T argument)
```
    Creates an ANY expression that contains one argument
    
    Type Parameters:
    
    T - String ot Expression object
    
    Parameters:
    
    argument - argument of any
    
    Returns:
    
    an ANY expression
  - any
```
@SafeVarargs
public static <T> Expression any(T... arguments)
```
    Creates an ANY expression that contains one argument
    
    Type Parameters:
    
    T - String ot Expression objects
    
    Parameters:
    
    arguments - argument of
    
    Returns:
    
    an ANY expression
  - some
```
public static <T> Expression some(T argument)
```
    Creates an SOME expression that contains one argument
    
    Type Parameters:
    
    T - String ot Expression object
    
    Parameters:
    
    argument - argument of any
    
    Returns:
    
    an SOME expression
  - some
```
@SafeVarargs
public static <T> Expression some(T... arguments)
```
    Creates an SOME expression that contains one argument
    
    Type Parameters:
    
    T - String ot Expression objects
    
    Parameters:
    
    arguments - argument of
    
    Returns:
    
    an SOME expression
  - asOperator
```
public static Expression asOperator(java.lang.String name,
                                    Expression expression)
```
    This is a synonym of asFunc(String, Expression). Examples: asOperator("ALL", asArray(List.of(1, 2))); // ALL(ARRAY[1, 2]) asOperator("SOME", asList(1, 2)); // SOME(1, 2)
    
    Parameters:
    
    name - - function or operator name, examples: ALL, ANY ...
    
    expression - - list or array expression
    
    Returns:
    
    a combine of name and expression objects
    
    See Also:
    
    asArray(Object[]), asList(Object[]), asFunc(String, Expression)
  - asOperator
```
@SafeVarargs
public static <T> Expression asOperator(java.lang.String name,
                                        T... arguments)
```
    This is a synonym of asFunc(String, Object[]).
    
    Parameters:
    
    name - of function
    
    arguments - arguments
    
    Returns:
    
    a function with list of arguments
    
    See Also:
    
    asOperator(String, Expression)
  - values
```
@SafeVarargs
public static <T> Expression values(T... expressions)
```
    VALUES list. Examples: values(asList(1, 2), asList(3, 4)); // VALUES(1, 2), (3, 4) // (VALUES(1, 2), (3, 4)) AS point(x, y) values(asList(1, 2), asList(3, 4)).as("point", "x", "y");
    
    Parameters:
    
    expressions - list of expressions
    
    Returns:
    
    VALUES expression
    
    See Also:
    
    asList(Object[])
  - asSubQuery
```
public static Expression asSubQuery(Query query)
```
    Parameters:
    
    query - subquery
    
    Returns:
    
    a subquery expression
  - operator
```
public static <T> Operator operator(T operator)
```
    Creates an operator which ordinarily is used by condition.
    
    Parameters:
    
    operator - LIKE, ILIKE, =, !=, @> etc.
    
    Returns:
    
    instance of Operator.
    Most useful operators are collected there:
    
    See Also:
    
    Operators
  - keyword
```
public static Keyword keyword(java.lang.String keyword)
```
    Creates a keyword which ordinarily is used to build SQL query.
    
    Parameters:
    
    keyword - SELECT, UPDATE, FROM, JOIN etc.
    
    Returns:
    
    instance of Keyword
    Most useful keywords are collected there:
    
    See Also:
    
    Operators
  - nodeMetadata
```
public static NodeMetadata nodeMetadata(Keyword keyword)
```
    NodeMetadata contains a metadata for tree node.
    
    Parameters:
    
    keyword - NodeMetadata is composed from keyword.
    
    Returns:
    
    node metadata
  - targetExpression
```
public static ConflictTarget targetExpression(java.lang.String expression)
```
    The type represents an index expression. ConflictTarget type is a part of INSERT .. ON CONFLICT clause
    
    Parameters:
    
    expression - index expression
    
    Returns:
    
    conflict target type
  - targetExpression
```
public static ConflictTarget targetExpression(java.lang.String expression,
                                              java.lang.String collation)
```
    The type represents an index expression. ConflictTarget type is a part of INSERT .. ON CONFLICT clause
    
    Parameters:
    
    expression - index expression
    
    collation - collation
    
    Returns:
    
    conflict target type
  - targetExpression
```
public static ConflictTarget targetExpression(java.lang.String expression,
                                              java.lang.String collation,
                                              java.lang.String opclass)
```
    The type represents an index expression. ConflictTarget type is a part of INSERT .. ON CONFLICT clause
    
    Parameters:
    
    expression - index expression
    
    collation - collation
    
    opclass - operator class
    
    Returns:
    
    conflict target type
  - targetColumn
```
public static ConflictTarget targetColumn(java.lang.String column)
```
    The type represents an index column. ConflictTarget type is a part of INSERT .. ON CONFLICT clause
    
    Parameters:
    
    column - index expression
    
    Returns:
    
    conflict target type
  - targetColumn
```
public static ConflictTarget targetColumn(java.lang.String column,
                                          java.lang.String collation)
```
    The type represents an index column. ConflictTarget type is a part of INSERT .. ON CONFLICT clause
    
    Parameters:
    
    column - index expression
    
    collation - collation
    
    Returns:
    
    conflict target type
  - targetColumn
```
public static ConflictTarget targetColumn(java.lang.String column,
                                          java.lang.String collation,
                                          java.lang.String opclass)
```
    The type represents an index column. ConflictTarget type is a part of INSERT .. ON CONFLICT clause
    
    Parameters:
    
    column - index expression
    
    collation - collation
    
    opclass - operator class
    
    Returns:
    
    conflict target type
  - orderBy
```
public static OrderBy orderBy(java.lang.String name)
```
    Creates an OrderBy object. It's used in SELECT .. ORDER BY clause.
    
    Parameters:
    
    name - column name
    
    Returns:
    
    OrderBy type
  - orderBy
```
public static OrderBy orderBy(java.lang.String name,
                              java.lang.String sorting)
```
    Creates an OrderBy object. It's used in SELECT .. ORDER BY clause.
    
    Parameters:
    
    name - column name or expression
    
    sorting - sorting constant: ASC | DESC | USING constant
    
    Returns:
    
    OrderBy type
  - orderBy
```
public static OrderBy orderBy(java.lang.String name,
                              java.lang.String sorting,
                              java.lang.String nulls)
```
    Creates an OrderBy object. It's used in SELECT .. ORDER BY clause.
    
    Parameters:
    
    name - 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:
    
    OrderBy type

Class Queryman

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Queryman

Method Detail

setTreeFactory

getTree

with

withRecursive

select

select

selectAll

selectAll

selectDistinct

selectDistinct

selectDistinctOn

selectDistinctOn

createSequence

createSequence

createTempSequence

createTempSequence

createTempSequenceIfNotExists

createTempSequenceIfNotExists

createSequenceIfNotExists

createSequenceIfNotExists

declare

deleteFrom

deleteFrom

deleteFromOnly

deleteFromOnly

update

update

updateOnly

updateOnly

insertInto

insertInto

condition

conditionBetween

conditionExists

conditionSome

conditionAny

conditionAll

from

from

fromOnly

fromOnly

asConstant

asConstant

asDate

asTime

asTimestamp

asDollarString

asDollarString

asName

asQuotedName

asList

asList

asArray

asArray

asFunc

asFunc

max

all

all

any

any

some

some

asOperator

asOperator

values

asSubQuery

operator

keyword

nodeMetadata

targetExpression

targetExpression

targetExpression