Package org.queryman.builder.command.impl

Class ConditionsImpl

java.lang.Object

org.queryman.builder.command.impl.ConditionsImpl

All Implemented Interfaces:

AstVisitor, Conditions

public final class ConditionsImpl
extends java.lang.Object
implements Conditions

Constructor Summary

Constructors

Constructor	Description
ConditionsImpl(NodeMetadata metadata, Query query)	It is used
ConditionsImpl(NodeMetadata metadata, Expression field, Conditions conditions)	Ordinarily this constructor is used by BETWEEN ..
ConditionsImpl(Conditions conditions)
ConditionsImpl(Expression field, NodeMetadata metadata, Query query)
ConditionsImpl(Expression leftValue, NodeMetadata metadata, Expression rightValue)

Method Summary

Modifier and Type	Method	Description
Conditions	and(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> Conditions	and(T leftValue, T operator, T rightValue)	Example: // SELECT * FROM book WHERE year > 2010 AND "id" = 1 select("*") .from("book") .where("year", ">", "2010") .and(asQuotedName("id"), operator("="), asNumber(1)) .sql()
Conditions	andExists(Query query)	Example: // SELECT * FROM book WHERE year > 2010 AND EXISTS (SELECT * FROM author) select("*") .from("book") .where("year", ">", "2010") .andExists(select("*").from("authors")) .sql()
Conditions	andNot(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> Conditions	andNot(T leftValue, T operator, T rightValue)	Example: // SELECT * FROM book WHERE year > 2010 AND NOT "id" = 1 select("*") .from("book") .where("year", ">", "2010") .andNot(asQuotedName("id"), operator("="), asNumber(1)) .sql()
Conditions	andNotExists(Query query)	Example: // SELECT * FROM book WHERE year > 2010 AND NOT EXISTS (SELECT * FROM author) select("*") .from("book") .where("year", ">", "2010") .andNotExists(select("*").from("authors")) .sql()
void	assemble(AbstractSyntaxTree tree)	Visits SQL query making a tree from its clauses.
Node	getNode()
Conditions	or(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> Conditions	or(T leftValue, T operator, T rightValue)	Example: // SELECT * FROM book WHERE year > 2010 OR id = 1 select("*") .from("book") .where("year", ">", "2010") .or("id", "=", "1") .sql()
Conditions	orExists(Query query)	Example: // SELECT * FROM book WHERE year > 2010 OR EXISTS (SELECT * FROM author) select("*") .from("book") .where("year", ">", "2010") .orExists(select("*").from("authors")) .sql()
Conditions	orNot(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> Conditions	orNot(T leftValue, T operator, T rightValue)	Example: // SELECT * FROM book WHERE year > 2010 OR NOT "id" = 1 select("*") .from("book") .where("year", ">", "2010") .orNot(asQuotedName("id"), "=", 1) .sql()
Conditions	orNotExists(Query query)	Example: // SELECT * FROM book WHERE year > 2010 OR NOT EXISTS (SELECT * FROM author) select("*") .from("book") .where("year", ">", "2010") .orNotExists(select("*").from("authors")) .sql()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ConditionsImpl

public ConditionsImpl(Expression leftValue,
                      NodeMetadata metadata,
                      Expression rightValue)

ConditionsImpl

public ConditionsImpl(NodeMetadata metadata,
                      Expression field,
                      Conditions conditions)

Ordinarily this constructor is used by BETWEEN .. AND .. clause.

Where:

Parameters:

metadata - - BETWEEN node metadata.

field - - field of between. Example: id BETWEEN ..

conditions - - condition of between. Example: id BETWEEN 1 AND 20

ConditionsImpl

public ConditionsImpl(Conditions conditions)

ConditionsImpl

public ConditionsImpl(NodeMetadata metadata,
                      Query query)

It is used

Parameters:

query -

ConditionsImpl

public ConditionsImpl(Expression field,
                      NodeMetadata metadata,
                      Query query)

Method Detail

and

public final <T> Conditions and(T leftValue,
                                T operator,
                                T rightValue)

Description copied from interface: Conditions

Example: // SELECT * FROM book WHERE year > 2010 AND "id" = 1 select("*") .from("book") .where("year", ">", "2010") .and(asQuotedName("id"), operator("="), asNumber(1)) .sql()

Specified by:

and in interface Conditions

Type Parameters:

T - String, Expression, Operator or Query object

Parameters:

leftValue - left operand

operator - operator

rightValue - right operand

and

public final Conditions and(Conditions conditions)

Description copied from interface: 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. See the first example.
• When the conditions is conditions are joined by AND, AND NOT, OR and OR NOT operators. These conditions is being a grouped condition, and will be surrounded by parentheses. See the second example.

The first example: // SELECT * FROM book WHERE year > 2010 AND id BETWEEN 1 AND 10 select("*") .from("book") .where("year", ">", "2010") .and(conditionBetween("id", "1", "10")) .sql() The second example: // SELECT * FROM book WHERE year > 2010 AND (id BETWEEN 1 AND 10 AND name = 'Advanced SQL') select("*") .from("book") .where("year", ">", "2010") .and( conditionBetween("id", "1", "10") .and(asName("name"), operator("="), asString("Advanced SQL")) ) .sql()

Specified by:

and in interface Conditions

Parameters:

conditions - condition

Returns:

itself Kind of conditions:

See Also:

Queryman.condition(Object, Object, Object)

andExists

public final Conditions andExists(Query query)

Description copied from interface: Conditions

Example: // SELECT * FROM book WHERE year > 2010 AND EXISTS (SELECT * FROM author) select("*") .from("book") .where("year", ">", "2010") .andExists(select("*").from("authors")) .sql()

Specified by:

andExists in interface Conditions

Parameters:

query - subquery

Returns:

itself

andNot

public final <T> Conditions andNot(T leftValue,
                                   T operator,
                                   T rightValue)

Description copied from interface: Conditions

Example: // SELECT * FROM book WHERE year > 2010 AND NOT "id" = 1 select("*") .from("book") .where("year", ">", "2010") .andNot(asQuotedName("id"), operator("="), asNumber(1)) .sql()

Specified by:

andNot in interface Conditions

Type Parameters:

T - String, Expression, Operator or Query object

Parameters:

leftValue - left operand

operator - operator

rightValue - right operand

andNot

public final Conditions andNot(Conditions conditions)

Description copied from interface: 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. See the first example.
• When the conditions is conditions are joined by AND, AND NOT, OR and OR NOT operators. These conditions is being a grouped condition, and will be surrounded by parentheses. See the second example.

The first example: // SELECT * FROM book WHERE year > 2010 AND NOT id BETWEEN 1 AND 10 select("*") .from("book") .where("year", ">", "2010") .andNot(conditionBetween("id", "1", "10")) .sql() The second example: // SELECT * FROM book WHERE year > 2010 AND NOT (id BETWEEN 1 AND 10 AND name = 'Advanced SQL') select("*") .from("book") .where("year", ">", "2010") .andNot( conditionBetween("id", "1", "10") ..and(asName("name"), operator("="), asString("Advanced SQL")) ) .sql()

Specified by:

andNot in interface Conditions

Parameters:

conditions - condition

Returns:

itself Kind of conditions:

See Also:

Queryman.condition(Object, Object, Object)

andNotExists

public final Conditions andNotExists(Query query)

Description copied from interface: Conditions

Example: // SELECT * FROM book WHERE year > 2010 AND NOT EXISTS (SELECT * FROM author) select("*") .from("book") .where("year", ">", "2010") .andNotExists(select("*").from("authors")) .sql()

Specified by:

andNotExists in interface Conditions

Parameters:

query - subquery

Returns:

itself

or

public final <T> Conditions or(T leftValue,
                               T operator,
                               T rightValue)

Description copied from interface: Conditions

Example: // SELECT * FROM book WHERE year > 2010 OR id = 1 select("*") .from("book") .where("year", ">", "2010") .or("id", "=", "1") .sql()

Specified by:

or in interface Conditions

Type Parameters:

T - String, Expression, Operator or Query object

Parameters:

leftValue - left operand

operator - operator

rightValue - right operand

or

public final Conditions or(Conditions conditions)

Description copied from interface: 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. See the first example.
• When the conditions is conditions are joined by AND, AND NOT, OR and OR NOT operators. These conditions is being a grouped condition, and will be surrounded by parentheses. See the second example.

The first example: // SELECT * FROM book WHERE year > 2010 OR id BETWEEN 1 AND 10 select("*") .from("book") .where("year", ">", "2010") .or(conditionBetween("id", "1", "10")) .sql() The second example: // SELECT * FROM book WHERE year > 2010 OR (id BETWEEN 1 AND 10 AND name = 'Advanced SQL') select("*") .from("book") .where("year", ">", "2010") .ir( conditionBetween("id", "1", "10") ..and(asName("name"), operator("="), asString("Advanced SQL")) ) .sql()

Specified by:

or in interface Conditions

Parameters:

conditions - condition

Returns:

itself Kind of conditions:

See Also:

Queryman.condition(Object, Object, Object)

orExists

public final Conditions orExists(Query query)

Description copied from interface: Conditions

Example: // SELECT * FROM book WHERE year > 2010 OR EXISTS (SELECT * FROM author) select("*") .from("book") .where("year", ">", "2010") .orExists(select("*").from("authors")) .sql()

Specified by:

orExists in interface Conditions

Parameters:

query - subquery

Returns:

itself

orNot

public final <T> Conditions orNot(T leftValue,
                                  T operator,
                                  T rightValue)

Description copied from interface: Conditions

Example: // SELECT * FROM book WHERE year > 2010 OR NOT "id" = 1 select("*") .from("book") .where("year", ">", "2010") .orNot(asQuotedName("id"), "=", 1) .sql()

Specified by:

orNot in interface Conditions

Type Parameters:

T - String, Expression, Operator or Query object

Parameters:

leftValue - left operand

operator - operator

rightValue - right operand

orNot

public final Conditions orNot(Conditions conditions)

Description copied from interface: 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. See the first example.
• When the conditions is conditions are joined by AND, AND NOT, OR and OR NOT operators. These conditions is being a grouped condition, and will be surrounded by parentheses. See the second example.

The first example: // SELECT * FROM book WHERE year > 2010 OR NOT id BETWEEN 1 AND 10 select("*") .from("book") .where("year", ">", "2010") .orNot(conditionBetween("id", "1", "10")) .sql() The second example: // SELECT * FROM book WHERE year > 2010 OR NOT (id BETWEEN 1 AND 10 AND name = 'Advanced SQL') select("*") .from("book") .where("year", ">", "2010") .orNot( conditionBetween("id", "1", "10") ..and(asName("name"), operator("="), asString("Advanced SQL")) ) .sql()

Specified by:

orNot in interface Conditions

Parameters:

conditions - condition

Returns:

itself Kind of conditions:

See Also:

Queryman.condition(Object, Object, Object)

orNotExists

public final Conditions orNotExists(Query query)

Description copied from interface: Conditions

Example: // SELECT * FROM book WHERE year > 2010 OR NOT EXISTS (SELECT * FROM author) select("*") .from("book") .where("year", ">", "2010") .orNotExists(select("*").from("authors")) .sql()

Specified by:

orNotExists in interface Conditions

Parameters:

query - subquery

Returns:

itself

getNode

public Node getNode()

Specified by:

getNode in interface Conditions

assemble

public 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