com.onewebsql.query
Class AExp

java.lang.Object
  extended by com.onewebsql.query.Exp
      extended by com.onewebsql.query.AExp
All Implemented Interfaces:
Expression
Direct Known Subclasses:
Alias, Column, Subselect, VirtualColumn

public class AExp
extends Exp

Represents an arithemetic expression i.e., the one which has arithmetic value.

It is convenient to distinguished to types of arithmetic expressions used in this component

expression type description
terminal expressions Expression which has a value. A terminal expression is created from an object representing this value.
nonterminal expressions Expression which is composed of other expression with arithmetical operations: addition, mulitplication, etc.


Field Summary
protected  String expression
          Part of SQL query which represents this expression.
protected  Value value
          An object representing the value of this expression, it will be bound to SQL query.
 
Fields inherited from class com.onewebsql.query.Exp
brackets, left, operator, right
 
Fields inherited from interface com.onewebsql.query.Expression
COMMA, DOT, LB, QUESTION_MARK, RB, SPACE
 
Constructor Summary
protected AExp()
          Creates an arithmetics expression without fililing the fields.
 
Method Summary
 AExp add(AExp exp)
          Creates a nonterminal arithmetic expression which represents which represents addition ('+').
static AExp add(AExp left, AExp right)
          Creates a nonterminal arithmetic expression which represents addition ('+').
 AExp add(BigDecimal exp)
          Creates a nonterminal arithmetic expression which represents which represents addition ('+').
 AExp add(double exp)
          Creates a nonterminal arithmetic expression which represents which represents addition ('+').
 AExp add(Double exp)
          Creates a nonterminal arithmetic expression which represents which represents addition ('+').
 AExp add(Float exp)
          Creates a nonterminal arithmetic expression which represents which represents addition ('+').
 AExp add(Integer exp)
          Creates a nonterminal arithmetic expression which represents which represents addition ('+').
 AExp add(long exp)
          Creates a nonterminal arithmetic expression which represents which represents addition ('+').
 AExp add(Long exp)
          Creates a nonterminal arithmetic expression which represents which represents addition ('+').
 AExp alias(String tableAlias, String columnAlias)
          Returns an expression which represents a reference to the expression using the specified table/column alias.
static AExp all(SelectQuery query)
          Creates a nonterminal arithmetic expression which represents the 'ALL' operation.
static AExp any(SelectQuery query)
          Creates a nonterminal arithmetic expression which represents the 'ANY' operation.
 LExp between(AExp lower, AExp greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(BigDecimal lower, BigDecimal greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(Date lower, Date greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(Date lower, Date greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(double lower, double greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(Double lower, Double greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(Float lower, Float greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(Integer lower, Integer greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(long lower, long greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(Long lower, Long greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(SelectQuery lower, SelectQuery greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(Timestamp lower, Timestamp greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
 LExp between(Time lower, Time greater)
          Creates a nonterminal logical expression using the operator 'BETWEEN'.
static AExp br(AExp exp)
          Puts parentheses around the specifed arithmetic expression.
 void build(StringBuilder sb, String schemaName, List<Value> objects, DBAdapter adapter)
          Builds the text of the query (or a part of it) represented by this object.
 AExp div(AExp exp)
          Creates a nonterminal arithmetic expression which represents which represents division ('/').
static AExp div(AExp left, AExp right)
          Creates a nonterminal arithmetic expression which represents division ('/').
 AExp div(BigDecimal exp)
          Creates a nonterminal arithmetic expression which represents which represents division ('/').
 AExp div(double exp)
          Creates a nonterminal arithmetic expression which represents which represents division ('/').
 AExp div(Double exp)
          Creates a nonterminal arithmetic expression which represents which represents division ('/').
 AExp div(Float exp)
          Creates a nonterminal arithmetic expression which represents which represents division ('/').
 AExp div(Integer exp)
          Creates a nonterminal arithmetic expression which represents which represents division ('/').
 AExp div(long exp)
          Creates a nonterminal arithmetic expression which represents which represents division ('/').
 AExp div(Long exp)
          Creates a nonterminal arithmetic expression which represents which represents division ('/').
 LExp eq(AExp exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(BigDecimal exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(boolean exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(Boolean exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(Date exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(Date exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(double exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(Double exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(Float exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(Integer exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(long exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(Long exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(Object exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(SelectQuery exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(String exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(Time exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 LExp eq(Timestamp exp)
          Creates a nonterminal logical expression using the equality operator ('=').
 boolean equals(Object obj)
           
static AExp exp(BigDecimal exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(boolean exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(Boolean exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(Byte exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(byte[] exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(Date exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(Date exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(double exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(Double exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(Float exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(Integer exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(long exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(Long exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(Object exp)
          Creates a terminal arithmetic expression from the specified parameter, choosing an appropriate JDBC type from the class of the parameter.
static AExp exp(Short exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(String exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(Time exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp exp(Timestamp exp)
          Creates a terminal arithmetic expression from the specified parameter.
static AExp fun(String name, AExp param)
          Creates a nonterminal arithmetic expression which represents invokation of an SQL function.
static AExp fun(String name, List<AExp> params)
          Creates a nonterminal arithmetic expression which represents invokation of an SQL function.
 LExp ge(AExp exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(BigDecimal exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(Date exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(Date exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(double exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(Double exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(Float exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(Integer exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(long exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(Long exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(SelectQuery exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(Time exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 LExp ge(Timestamp exp)
          Creates a nonterminal logical expression using the greater than or equal operator ('>=').
 Value getValue()
          Returns the value of the 'value' field.
 LExp gt(AExp exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(BigDecimal exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(Date exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(Date exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(double exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(Double exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(Float exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(Integer exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(long exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(Long exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(SelectQuery exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(Time exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 LExp gt(Timestamp exp)
          Creates a nonterminal logical expression using the greater than operator ('>').
 int hashCode()
           
 LExp ilike(String exp)
          Creates a nonterminal logical expression using the operator 'ILIKE' (case-insensitive 'LIKE').
 LExp ilike(String exp, Locale locale)
          Creates a nonterminal logical expression using the operator 'ILIKE' (case-insensitive 'LIKE').
 LExp in(Collection<AExp> params)
          Creates a terminal logical expression using the operator 'IN' and a specified list of AExp objects.
 LExp in(SelectQuery query)
          Creates a terminal logical expression using the operator 'IN'.
 LExp inIds(Collection<? extends Object> params)
          Creates a terminal logical expression using the operator 'IN' with the list of ids retrieved from the specified objects.
 LExp inIds(Collection<? extends Object> params, String idColumnName)
          Creates a terminal logical expression using the operator 'IN' and the list of values of the property idColumName retrieved from the specified objects.
 LExp inValues(Collection<? extends Object> params)
          Creates a terminal logical expression using the operator 'IN' with the specified list of objects.
 LExp le(AExp exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(BigDecimal exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(Date exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(Date exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(double exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(Double exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(Float exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(Integer exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(long exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(Long exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(SelectQuery exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(Time exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp le(Timestamp exp)
          Creates a nonterminal logical expression using the less or equal than operator ('<=').
 LExp like(AExp exp)
          Creates a nonterminal logical expression using the operator 'LIKE'.
 LExp like(String exp)
          Creates a nonterminal logical expression using the operator 'LIKE'.
 LExp lt(AExp exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(BigDecimal exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(Date exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(Date exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(double exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(Double exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(Float exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(Integer exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(long exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(Long exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(SelectQuery exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(Time exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 LExp lt(Timestamp exp)
          Creates a nonterminal logical expression using the less than operator ('<').
 AExp mul(AExp exp)
          Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*').
static AExp mul(AExp left, AExp right)
          Creates a nonterminal arithmetic expression which represents multiplication ('*').
 AExp mul(BigDecimal exp)
          Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*').
 AExp mul(double exp)
          Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*').
 AExp mul(Double exp)
          Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*').
 AExp mul(Float exp)
          Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*').
 AExp mul(Integer exp)
          Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*').
 AExp mul(long exp)
          Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*').
 AExp mul(Long exp)
          Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*').
 LExp ne(AExp exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(BigDecimal exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(boolean exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(Boolean exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(Date exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(Date exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(double exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(Double exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(Float exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(Integer exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(long exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(Long exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(SelectQuery exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(String exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(Time exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
 LExp ne(Timestamp exp)
          Creates a nonterminal logical expression using the inequality operator ('<>').
static AExp neg(AExp right)
          Creates a nonterminal arithmetic expression which represents a negation (single argumetn '-').
static AExp some(SelectQuery query)
          Creates a nonterminal arithmetic expression which represents the 'SOME' operation.
 AExp sub(AExp exp)
          Creates a nonterminal arithmetic expression which represents which represents subtraction ('-').
static AExp sub(AExp left, AExp right)
          Creates a nonterminal arithmetic expression which represents substraction ('-').
 AExp sub(BigDecimal exp)
          Creates a nonterminal arithmetic expression which represents which represents subtraction ('-').
 AExp sub(double exp)
          Creates a nonterminal arithmetic expression which represents which represents subtraction ('-').
 AExp sub(Double exp)
          Creates a nonterminal arithmetic expression which represents which represents subtraction ('-').
 AExp sub(Float exp)
          Creates a nonterminal arithmetic expression which represents which represents subtraction ('-').
 AExp sub(Integer exp)
          Creates a nonterminal arithmetic expression which represents which represents subtraction ('-').
 AExp sub(long exp)
          Creates a nonterminal arithmetic expression which represents which represents subtraction ('-').
 AExp sub(Long exp)
          Creates a nonterminal arithmetic expression which represents which represents subtraction ('-').
 String toString()
          Returns a string representation of the object.
 
Methods inherited from class com.onewebsql.query.Exp
aliasColumn, aliasTable
 
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
 

Field Detail

expression

protected String expression
Part of SQL query which represents this expression. It is used only in terminal expressions.


value

protected Value value
An object representing the value of this expression, it will be bound to SQL query. It is used only in terminal expressions.

Constructor Detail

AExp

protected AExp()
Creates an arithmetics expression without fililing the fields. Only for the brave! :-) Used in Column which inherits from this class.

Method Detail

br

public static AExp br(AExp exp)
Puts parentheses around the specifed arithmetic expression.

Parameters:
exp - arithmetic expression
Returns:
an arithmetic expreesion exp with parentheses around it

exp

public static AExp exp(boolean exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(long exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(double exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Boolean exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Integer exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Byte exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Short exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Long exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Float exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Double exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(BigDecimal exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(String exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Date exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Date exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Time exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Timestamp exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(byte[] exp)
Creates a terminal arithmetic expression from the specified parameter.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression

exp

public static AExp exp(Object exp)
Creates a terminal arithmetic expression from the specified parameter, choosing an appropriate JDBC type from the class of the parameter. The supported classes are: If the parameter is an object of a different class, an IllegalArgumentException is thrown.

Parameters:
exp - the value of the expression
Returns:
the created terminal arithmetic expression
Throws:
IllegalArgumentException - if the parameter is null or it is not an object of the supported class

add

public static AExp add(AExp left,
                       AExp right)
Creates a nonterminal arithmetic expression which represents addition ('+'). Puts parentheses around the query.

Parameters:
left - left operand
right - right operand
Returns:
the created arithmetic expression

sub

public static AExp sub(AExp left,
                       AExp right)
Creates a nonterminal arithmetic expression which represents substraction ('-'). Puts parentheses around the query.

Parameters:
left - left operand
right - right operand
Returns:
the created arithmetic expression

mul

public static AExp mul(AExp left,
                       AExp right)
Creates a nonterminal arithmetic expression which represents multiplication ('*'). Puts parentheses around the query.

Parameters:
left - left operand
right - right operand
Returns:
the created arithmetic expression

div

public static AExp div(AExp left,
                       AExp right)
Creates a nonterminal arithmetic expression which represents division ('/'). Puts parentheses around the query.

Parameters:
left - left operand
right - right operand
Returns:
the created arithmetic expression

neg

public static AExp neg(AExp right)
Creates a nonterminal arithmetic expression which represents a negation (single argumetn '-'). Puts parentheses around the query.

Parameters:
right - right operand
Returns:
the created arithmetic expression

fun

public static AExp fun(String name,
                       AExp param)
Creates a nonterminal arithmetic expression which represents invokation of an SQL function.

Parameters:
name - name of the invoked function
param - function parameter
Returns:
the created arithmetic expression

fun

public static AExp fun(String name,
                       List<AExp> params)
Creates a nonterminal arithmetic expression which represents invokation of an SQL function.

Parameters:
name - name of the invoked function
params - function parameters
Returns:
the created arithmetic expression

all

public static AExp all(SelectQuery query)
Creates a nonterminal arithmetic expression which represents the 'ALL' operation.

Parameters:
query - SELECT query
Returns:
the created arithmetic expression

any

public static AExp any(SelectQuery query)
Creates a nonterminal arithmetic expression which represents the 'ANY' operation.

Parameters:
query - SELECT query
Returns:
the created arithmetic expression

some

public static AExp some(SelectQuery query)
Creates a nonterminal arithmetic expression which represents the 'SOME' operation.

Parameters:
query - SELECT query
Returns:
the created arithmetic expression

add

public AExp add(AExp exp)
Creates a nonterminal arithmetic expression which represents which represents addition ('+'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

add

public AExp add(long exp)
Creates a nonterminal arithmetic expression which represents which represents addition ('+'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

add

public AExp add(double exp)
Creates a nonterminal arithmetic expression which represents which represents addition ('+'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

add

public AExp add(Integer exp)
Creates a nonterminal arithmetic expression which represents which represents addition ('+'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

add

public AExp add(Long exp)
Creates a nonterminal arithmetic expression which represents which represents addition ('+'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

add

public AExp add(Float exp)
Creates a nonterminal arithmetic expression which represents which represents addition ('+'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

add

public AExp add(Double exp)
Creates a nonterminal arithmetic expression which represents which represents addition ('+'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

add

public AExp add(BigDecimal exp)
Creates a nonterminal arithmetic expression which represents which represents addition ('+'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

sub

public AExp sub(AExp exp)
Creates a nonterminal arithmetic expression which represents which represents subtraction ('-'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

sub

public AExp sub(long exp)
Creates a nonterminal arithmetic expression which represents which represents subtraction ('-'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

sub

public AExp sub(double exp)
Creates a nonterminal arithmetic expression which represents which represents subtraction ('-'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

sub

public AExp sub(Integer exp)
Creates a nonterminal arithmetic expression which represents which represents subtraction ('-'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

sub

public AExp sub(Long exp)
Creates a nonterminal arithmetic expression which represents which represents subtraction ('-'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

sub

public AExp sub(Float exp)
Creates a nonterminal arithmetic expression which represents which represents subtraction ('-'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

sub

public AExp sub(Double exp)
Creates a nonterminal arithmetic expression which represents which represents subtraction ('-'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

sub

public AExp sub(BigDecimal exp)
Creates a nonterminal arithmetic expression which represents which represents subtraction ('-'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

mul

public AExp mul(AExp exp)
Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

mul

public AExp mul(long exp)
Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

mul

public AExp mul(double exp)
Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

mul

public AExp mul(Integer exp)
Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

mul

public AExp mul(Long exp)
Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

mul

public AExp mul(Float exp)
Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

mul

public AExp mul(Double exp)
Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

mul

public AExp mul(BigDecimal exp)
Creates a nonterminal arithmetic expression which represents which represents mutliplication ('*'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

div

public AExp div(AExp exp)
Creates a nonterminal arithmetic expression which represents which represents division ('/'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

div

public AExp div(long exp)
Creates a nonterminal arithmetic expression which represents which represents division ('/'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

div

public AExp div(double exp)
Creates a nonterminal arithmetic expression which represents which represents division ('/'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

div

public AExp div(Integer exp)
Creates a nonterminal arithmetic expression which represents which represents division ('/'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

div

public AExp div(Long exp)
Creates a nonterminal arithmetic expression which represents which represents division ('/'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

div

public AExp div(Float exp)
Creates a nonterminal arithmetic expression which represents which represents division ('/'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

div

public AExp div(Double exp)
Creates a nonterminal arithmetic expression which represents which represents division ('/'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

div

public AExp div(BigDecimal exp)
Creates a nonterminal arithmetic expression which represents which represents division ('/'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created arithmetic expression

eq

public LExp eq(AExp exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(boolean exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(long exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(double exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(Boolean exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(Integer exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(Long exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(Float exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(Double exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(BigDecimal exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(String exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(Date exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(Date exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(Time exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(Timestamp exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(SelectQuery exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

eq

public LExp eq(Object exp)
Creates a nonterminal logical expression using the equality operator ('='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression. The right operand is created by the method exp(Object).

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(AExp exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(boolean exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(long exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(double exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(Boolean exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(Integer exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(Long exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(Float exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(Double exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(BigDecimal exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(String exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(Date exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(Date exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(Time exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(Timestamp exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ne

public LExp ne(SelectQuery exp)
Creates a nonterminal logical expression using the inequality operator ('<>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(AExp exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(long exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(double exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(Integer exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(Long exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(Float exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(Double exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(BigDecimal exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(Date exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(Date exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(Time exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(Timestamp exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

gt

public LExp gt(SelectQuery exp)
Creates a nonterminal logical expression using the greater than operator ('>'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(AExp exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(long exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(double exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(Integer exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(Long exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(Float exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(Double exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(BigDecimal exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(Date exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(Date exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(Time exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(Timestamp exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ge

public LExp ge(SelectQuery exp)
Creates a nonterminal logical expression using the greater than or equal operator ('>='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(AExp exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(long exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(double exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(Integer exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(Long exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(Float exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(Double exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(BigDecimal exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(Date exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(Date exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(Time exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(Timestamp exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

lt

public LExp lt(SelectQuery exp)
Creates a nonterminal logical expression using the less than operator ('<'). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(AExp exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(long exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(double exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(Integer exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(Long exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(Float exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(Double exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(BigDecimal exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(Date exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(Date exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(Time exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(Timestamp exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

le

public LExp le(SelectQuery exp)
Creates a nonterminal logical expression using the less or equal than operator ('<='). It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

like

public LExp like(AExp exp)
Creates a nonterminal logical expression using the operator 'LIKE'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

like

public LExp like(String exp)
Creates a nonterminal logical expression using the operator 'LIKE'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ilike

public LExp ilike(String exp)
Creates a nonterminal logical expression using the operator 'ILIKE' (case-insensitive 'LIKE'). It uses this arithmetic expression as left operand. Special search characters ('%' and '_') are escaped. It does not put parentheses around the created expression.

Parameters:
exp - right operand
Returns:
the created logical expression

ilike

public LExp ilike(String exp,
                  Locale locale)
Creates a nonterminal logical expression using the operator 'ILIKE' (case-insensitive 'LIKE'). It uses this arithmetic expression as left operand. Special search characters ('%' and '_') are escaped. It does not put parentheses around the created expression.

Parameters:
exp - right operand
locale - locale changing the letter case
Returns:
the created logical expression

between

public LExp between(AExp lower,
                    AExp greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(long lower,
                    long greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(double lower,
                    double greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(Integer lower,
                    Integer greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(Long lower,
                    Long greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(Float lower,
                    Float greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(Double lower,
                    Double greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(BigDecimal lower,
                    BigDecimal greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(Date lower,
                    Date greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(Date lower,
                    Date greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(Time lower,
                    Time greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(Timestamp lower,
                    Timestamp greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

between

public LExp between(SelectQuery lower,
                    SelectQuery greater)
Creates a nonterminal logical expression using the operator 'BETWEEN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
lower - lower limit
greater - greater limit
Returns:
the created logical expression

in

public LExp in(Collection<AExp> params)
Creates a terminal logical expression using the operator 'IN' and a specified list of AExp objects. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression. If the parameter list is empty, it returns LExp.FALSE.

Parameters:
params - the list of AExp expression
Returns:
the created logical expression, LExp.FALSE if the list is empty

inValues

public LExp inValues(Collection<? extends Object> params)
Creates a terminal logical expression using the operator 'IN' with the specified list of objects. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
params - the list of objects
Returns:
the created logical expression

inIds

public LExp inIds(Collection<? extends Object> params)
Creates a terminal logical expression using the operator 'IN' with the list of ids retrieved from the specified objects. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
params - the list of objects which have 'id' parameter
Returns:
the created logical expression

inIds

public LExp inIds(Collection<? extends Object> params,
                  String idColumnName)
Creates a terminal logical expression using the operator 'IN' and the list of values of the property idColumName retrieved from the specified objects. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
params - the list of objects which have idColumName parameter
idColumnName - name of the property to be read
Returns:
the created logical expression

in

public LExp in(SelectQuery query)
Creates a terminal logical expression using the operator 'IN'. It uses this arithmetic expression as left operand. It does not put parentheses around the created expression.

Parameters:
query - SELECT query
Returns:
the created logical expression

build

public void build(StringBuilder sb,
                  String schemaName,
                  List<Value> objects,
                  DBAdapter adapter)
Description copied from interface: Expression
Builds the text of the query (or a part of it) represented by this object.

Specified by:
build in interface Expression
Overrides:
build in class Exp
Parameters:
sb - StringBuilder to build the query text
schemaName - name of the database schema used to build the query
objects - an accumulator list to which query parameters are appended
adapter - database adapter which builds builds query in a way specific to the database engine

alias

public AExp alias(String tableAlias,
                  String columnAlias)
Description copied from class: Exp
Returns an expression which represents a reference to the expression using the specified table/column alias.

Specified by:
alias in class Exp
Parameters:
tableAlias - table alias
columnAlias - column alias
Returns:
aliased expression

hashCode

public int hashCode()
Overrides:
hashCode in class Exp

equals

public boolean equals(Object obj)
Overrides:
equals in class Exp

toString

public String toString()
Description copied from class: Exp
Returns a string representation of the object. The representation consists of the value of the field "name".

Overrides:
toString in class Exp
Returns:
a string representation of the object.

getValue

public Value getValue()
Returns the value of the 'value' field.

Returns:
value of the 'value' field


Copyright © 2011-2013 e-point SA. All Rights Reserved.