Restrictions() 
{
		//cannot be instantiated
}

 public static Criterion allEq(Map propertyNameValues) 
{
		Conjunction conj = conjunction();
		Iterator iter = propertyNameValues.entrySet().iterator();
		while ( iter.hasNext() ) {
			Map.Entry me = (Map.Entry) iter.next();
			conj.add( eq( (String) me.getKey(), me.getValue() ) );
		}
		return conj;
}

Apply an "equals" constraint to each property in the key set of a Map

 public static LogicalExpression and(Criterion lhs,
    Criterion rhs) 
{
		return new LogicalExpression(lhs, rhs, "and");
}

Return the conjuction of two expressions

 public static Criterion between(String propertyName,
    Object lo,
    Object hi) 
{
		return new BetweenExpression(propertyName, lo, hi);
}

Apply a "between" constraint to the named property

 public static Conjunction conjunction() 
{
		return new Conjunction();
}

Group expressions together in a single conjunction (A and B and C...)

 public static Disjunction disjunction() 
{
		return new Disjunction();
}

Group expressions together in a single disjunction (A or B or C...)

 public static SimpleExpression eq(String propertyName,
    Object value) 
{
		return new SimpleExpression(propertyName, value, "=");
}

Apply an "equal" constraint to the named property

 public static PropertyExpression eqProperty(String propertyName,
    String otherPropertyName) 
{
		return new PropertyExpression(propertyName, otherPropertyName, "=");
}

Apply an "equal" constraint to two properties

 public static SimpleExpression ge(String propertyName,
    Object value) 
{
		return new SimpleExpression(propertyName, value, " >=");
}

Apply a "greater than or equal" constraint to the named property

 public static PropertyExpression geProperty(String propertyName,
    String otherPropertyName) 
{
		return new PropertyExpression(propertyName, otherPropertyName, " >=");
}

Apply a "greater than or equal" constraint to two properties

 public static SimpleExpression gt(String propertyName,
    Object value) 
{
		return new SimpleExpression(propertyName, value, " >");
}

Apply a "greater than" constraint to the named property

 public static PropertyExpression gtProperty(String propertyName,
    String otherPropertyName) 
{
		return new PropertyExpression(propertyName, otherPropertyName, " >");
}

Apply a "greater than" constraint to two properties

 public static Criterion idEq(Object value) 
{
		return new IdentifierEqExpression(value);
}

Apply an "equal" constraint to the identifier property

 public static Criterion ilike(String propertyName,
    Object value) 
{
		return new IlikeExpression(propertyName, value);
}

A case-insensitive "like", similar to Postgres ilike operator

 public static Criterion ilike(String propertyName,
    String value,
    MatchMode matchMode) 
{
		return new IlikeExpression(propertyName, value, matchMode);
}

A case-insensitive "like", similar to Postgres ilike operator

 public static Criterion in(String propertyName,
    Object[] values) 
{
		return new InExpression(propertyName, values);
}

Apply an "in" constraint to the named property

 public static Criterion in(String propertyName,
    Collection values) 
{
		return new InExpression( propertyName, values.toArray() );
}

Apply an "in" constraint to the named property

 public static Criterion isEmpty(String propertyName) 
{
		return new EmptyExpression(propertyName);
}

Constrain a collection valued property to be empty

 public static Criterion isNotEmpty(String propertyName) 
{
		return new NotEmptyExpression(propertyName);
}

Constrain a collection valued property to be non-empty

 public static Criterion isNotNull(String propertyName) 
{
		return new NotNullExpression(propertyName);
}

Apply an "is not null" constraint to the named property

 public static Criterion isNull(String propertyName) 
{
		return new NullExpression(propertyName);
}

Apply an "is null" constraint to the named property

 public static SimpleExpression le(String propertyName,
    Object value) 
{
		return new SimpleExpression(propertyName, value, "< =");
}

Apply a "less than or equal" constraint to the named property

 public static PropertyExpression leProperty(String propertyName,
    String otherPropertyName) 
{
		return new PropertyExpression(propertyName, otherPropertyName, "< =");
}

Apply a "less than or equal" constraint to two properties

 public static SimpleExpression like(String propertyName,
    Object value) 
{
		return new SimpleExpression(propertyName, value, " like ");
}

Apply a "like" constraint to the named property

 public static SimpleExpression like(String propertyName,
    String value,
    MatchMode matchMode) 
{
		return new SimpleExpression(propertyName, matchMode.toMatchString(value), " like " );
}

Apply a "like" constraint to the named property

 public static SimpleExpression lt(String propertyName,
    Object value) 
{
		return new SimpleExpression(propertyName, value, "< ");
}

Apply a "less than" constraint to the named property

 public static PropertyExpression ltProperty(String propertyName,
    String otherPropertyName) 
{
		return new PropertyExpression(propertyName, otherPropertyName, "< ");
}

Apply a "less than" constraint to two properties

 public static NaturalIdentifier naturalId() 
{
		return new NaturalIdentifier();
}

 public static SimpleExpression ne(String propertyName,
    Object value) 
{
		return new SimpleExpression(propertyName, value, "<  >");
}

Apply a "not equal" constraint to the named property

 public static PropertyExpression neProperty(String propertyName,
    String otherPropertyName) 
{
		return new PropertyExpression(propertyName, otherPropertyName, "<  >");
}

Apply a "not equal" constraint to two properties

 public static Criterion not(Criterion expression) 
{
		return new NotExpression(expression);
}

Return the negation of an expression

 public static LogicalExpression or(Criterion lhs,
    Criterion rhs) 
{
		return new LogicalExpression(lhs, rhs, "or");
}

Return the disjuction of two expressions

 public static Criterion sizeEq(String propertyName,
    int size) 
{
		return new SizeExpression(propertyName, size, "=");
}

Constrain a collection valued property by size

 public static Criterion sizeGe(String propertyName,
    int size) 
{
		return new SizeExpression(propertyName, size, "< =");
}

Constrain a collection valued property by size

 public static Criterion sizeGt(String propertyName,
    int size) 
{
		return new SizeExpression(propertyName, size, "< ");
}

Constrain a collection valued property by size

 public static Criterion sizeLe(String propertyName,
    int size) 
{
		return new SizeExpression(propertyName, size, " >=");
}

Constrain a collection valued property by size

 public static Criterion sizeLt(String propertyName,
    int size) 
{
		return new SizeExpression(propertyName, size, " >");
}

Constrain a collection valued property by size

 public static Criterion sizeNe(String propertyName,
    int size) 
{
		return new SizeExpression(propertyName, size, "<  >");
}

Constrain a collection valued property by size

 public static Criterion sqlRestriction(String sql) 
{
		return new SQLCriterion(sql, ArrayHelper.EMPTY_OBJECT_ARRAY, ArrayHelper.EMPTY_TYPE_ARRAY);
}

Apply a constraint expressed in SQL. Any occurrences of {alias} will be replaced by the table alias.

 public static Criterion sqlRestriction(String sql,
    Object[] values,
    Type[] types) 
{
		return new SQLCriterion(sql, values, types);
}

Apply a constraint expressed in SQL, with the given JDBC parameters. Any occurrences of {alias} will be replaced by the table alias.

 public static Criterion sqlRestriction(String sql,
    Object value,
    Type type) 
{
		return new SQLCriterion(sql, new Object[] { value }, new Type[] { type } );
}

Apply a constraint expressed in SQL, with the given JDBC parameter. Any occurrences of {alias} will be replaced by the table alias.