/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
 */
package org.hibernate.criterion;

import java.util.Collection;
import java.util.Map;

import org.hibernate.type.Type;

The criterion package may be used by applications as a framework for building new kinds of Criterion. However, it is intended that most applications will simply use the built-in criterion types via the static factory methods of this class. See also the Projections factory methods for generating Projection instances
Author:Gavin King, Steve Ebersole
See Also:
/** * The <tt>criterion</tt> package may be used by applications as a framework for building * new kinds of <tt>Criterion</tt>. However, it is intended that most applications will * simply use the built-in criterion types via the static factory methods of this class. * * See also the {@link Projections} factory methods for generating {@link Projection} instances * * @author Gavin King * @author Steve Ebersole * * @see org.hibernate.Criteria */
public class Restrictions {
Apply an "equal" constraint to the identifier property
Params:
  • value – The value to use in comparison
See Also:
Returns:Criterion
/** * Apply an "equal" constraint to the identifier property * * @param value The value to use in comparison * * @return Criterion * * @see IdentifierEqExpression */
public static Criterion idEq(Object value) { return new IdentifierEqExpression( value ); }
Apply an "equal" constraint to the named property
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
See Also:
Returns:SimpleExpression
/** * Apply an "equal" constraint to the named property * * @param propertyName The name of the property * @param value The value to use in comparison * * @return SimpleExpression * * @see SimpleExpression */
public static SimpleExpression eq(String propertyName, Object value) { return new SimpleExpression( propertyName, value, "=" ); }
Apply an "equal" constraint to the named property. If the value is null, instead apply "is null".
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
See Also:
Returns:The Criterion
/** * Apply an "equal" constraint to the named property. If the value * is null, instead apply "is null". * * @param propertyName The name of the property * @param value The value to use in comparison * * @return The Criterion * * @see #eq * @see #isNull */
public static Criterion eqOrIsNull(String propertyName, Object value) { return value == null ? isNull( propertyName ) : eq( propertyName, value ); }
Apply a "not equal" constraint to the named property
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
See Also:
Returns:The Criterion
/** * Apply a "not equal" constraint to the named property * * @param propertyName The name of the property * @param value The value to use in comparison * * @return The Criterion * @see SimpleExpression */
public static SimpleExpression ne(String propertyName, Object value) { return new SimpleExpression( propertyName, value, "<>" ); }
Apply a "not equal" constraint to the named property. If the value is null, instead apply "is not null".
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
See Also:
Returns:The Criterion
/** * Apply a "not equal" constraint to the named property. If the value * is null, instead apply "is not null". * * @param propertyName The name of the property * @param value The value to use in comparison * * @return The Criterion * * @see #ne * @see #isNotNull */
public static Criterion neOrIsNotNull(String propertyName, Object value) { return value == null ? isNotNull( propertyName ) : ne( propertyName, value ); }
Apply a "like" constraint to the named property
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
See Also:
Returns:The Criterion
/** * Apply a "like" constraint to the named property * * @param propertyName The name of the property * @param value The value to use in comparison * * @return The Criterion * * @see SimpleExpression */
public static SimpleExpression like(String propertyName, Object value) { // todo : update this to use LikeExpression return new SimpleExpression( propertyName, value, " like " ); }
Apply a "like" constraint to the named property using the provided match mode
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
  • matchMode – The match mode to use in comparison
See Also:
Returns:The Criterion
/** * Apply a "like" constraint to the named property using the provided match mode * * @param propertyName The name of the property * @param value The value to use in comparison * @param matchMode The match mode to use in comparison * * @return The Criterion * * @see SimpleExpression */
public static SimpleExpression like(String propertyName, String value, MatchMode matchMode) { // todo : update this to use LikeExpression return new SimpleExpression( propertyName, matchMode.toMatchString( value ), " like " ); }
A case-insensitive "like" (similar to Postgres ilike operator)
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
See Also:
Returns:The Criterion
/** * A case-insensitive "like" (similar to Postgres <tt>ilike</tt> operator) * * @param propertyName The name of the property * @param value The value to use in comparison * * @return The Criterion * * @see LikeExpression */
public static Criterion ilike(String propertyName, Object value) { if ( value == null ) { throw new IllegalArgumentException( "Comparison value passed to ilike cannot be null" ); } return ilike( propertyName, value.toString(), MatchMode.EXACT ); }
A case-insensitive "like" (similar to Postgres ilike operator) using the provided match mode
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
  • matchMode – The match mode to use in comparison
See Also:
Returns:The Criterion
/** * A case-insensitive "like" (similar to Postgres <tt>ilike</tt> operator) using the provided match mode * * @param propertyName The name of the property * @param value The value to use in comparison * @param matchMode The match mode to use in comparison * * @return The Criterion * * @see LikeExpression */
public static Criterion ilike(String propertyName, String value, MatchMode matchMode) { if ( value == null ) { throw new IllegalArgumentException( "Comparison value passed to ilike cannot be null" ); } return new LikeExpression( propertyName, value, matchMode, null, true ); }
Apply a "greater than" constraint to the named property
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
See Also:
Returns:The Criterion
/** * Apply a "greater than" constraint to the named property * * @param propertyName The name of the property * @param value The value to use in comparison * * @return The Criterion * * @see SimpleExpression */
public static SimpleExpression gt(String propertyName, Object value) { return new SimpleExpression( propertyName, value, ">" ); }
Apply a "less than" constraint to the named property
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
See Also:
Returns:The Criterion
/** * Apply a "less than" constraint to the named property * * @param propertyName The name of the property * @param value The value to use in comparison * * @return The Criterion * * @see SimpleExpression */
public static SimpleExpression lt(String propertyName, Object value) { return new SimpleExpression( propertyName, value, "<" ); }
Apply a "less than or equal" constraint to the named property
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
See Also:
Returns:The Criterion
/** * Apply a "less than or equal" constraint to the named property * * @param propertyName The name of the property * @param value The value to use in comparison * * @return The Criterion * * @see SimpleExpression */
public static SimpleExpression le(String propertyName, Object value) { return new SimpleExpression( propertyName, value, "<=" ); }
Apply a "greater than or equal" constraint to the named property
Params:
  • propertyName – The name of the property
  • value – The value to use in comparison
See Also:
Returns:The Criterion
/** * Apply a "greater than or equal" constraint to the named property * * @param propertyName The name of the property * @param value The value to use in comparison * * @return The Criterion * * @see SimpleExpression */
public static SimpleExpression ge(String propertyName, Object value) { return new SimpleExpression( propertyName, value, ">=" ); }
Apply a "between" constraint to the named property
Params:
  • propertyName – The name of the property
  • low – The low value
  • high – The high value
See Also:
Returns:The Criterion
/** * Apply a "between" constraint to the named property * * @param propertyName The name of the property * @param low The low value * @param high The high value * * @return The Criterion * * @see BetweenExpression */
public static Criterion between(String propertyName, Object low, Object high) { return new BetweenExpression( propertyName, low, high ); }
Apply an "in" constraint to the named property.
Params:
  • propertyName – The name of the property
  • values – The literal values to use in the IN restriction
See Also:
Returns:The Criterion
/** * Apply an "in" constraint to the named property. * * @param propertyName The name of the property * @param values The literal values to use in the IN restriction * * @return The Criterion * * @see InExpression */
public static Criterion in(String propertyName, Object... values) { return new InExpression( propertyName, values ); }
Apply an "in" constraint to the named property.
Params:
  • propertyName – The name of the property
  • values – The literal values to use in the IN restriction
See Also:
Returns:The Criterion
/** * Apply an "in" constraint to the named property. * * @param propertyName The name of the property * @param values The literal values to use in the IN restriction * * @return The Criterion * * @see InExpression */
public static Criterion in(String propertyName, Collection values) { return new InExpression( propertyName, values.toArray() ); }
Apply an "is null" constraint to the named property
Params:
  • propertyName – The name of the property
See Also:
Returns:Criterion
/** * Apply an "is null" constraint to the named property * * @param propertyName The name of the property * * @return Criterion * * @see NullExpression */
public static Criterion isNull(String propertyName) { return new NullExpression( propertyName ); }
Apply an "is not null" constraint to the named property
Params:
  • propertyName – The property name
See Also:
Returns:The Criterion
/** * Apply an "is not null" constraint to the named property * * @param propertyName The property name * * @return The Criterion * * @see NotNullExpression */
public static Criterion isNotNull(String propertyName) { return new NotNullExpression( propertyName ); }
Apply an "equal" constraint to two properties
Params:
  • propertyName – One property name
  • otherPropertyName – The other property name
See Also:
Returns:The Criterion
/** * Apply an "equal" constraint to two properties * * @param propertyName One property name * @param otherPropertyName The other property name * * @return The Criterion * * @see PropertyExpression */
public static PropertyExpression eqProperty(String propertyName, String otherPropertyName) { return new PropertyExpression( propertyName, otherPropertyName, "=" ); }
Apply a "not equal" constraint to two properties
Params:
  • propertyName – One property name
  • otherPropertyName – The other property name
See Also:
Returns:The Criterion
/** * Apply a "not equal" constraint to two properties * * @param propertyName One property name * @param otherPropertyName The other property name * * @return The Criterion * * @see PropertyExpression */
public static PropertyExpression neProperty(String propertyName, String otherPropertyName) { return new PropertyExpression( propertyName, otherPropertyName, "<>" ); }
Apply a "less than" constraint to two properties
Params:
  • propertyName – One property name
  • otherPropertyName – The other property name
See Also:
Returns:The Criterion
/** * Apply a "less than" constraint to two properties * * @param propertyName One property name * @param otherPropertyName The other property name * * @return The Criterion * * @see PropertyExpression */
public static PropertyExpression ltProperty(String propertyName, String otherPropertyName) { return new PropertyExpression( propertyName, otherPropertyName, "<" ); }
Apply a "less than or equal" constraint to two properties
Params:
  • propertyName – One property name
  • otherPropertyName – The other property name
See Also:
Returns:The Criterion
/** * Apply a "less than or equal" constraint to two properties * * @param propertyName One property name * @param otherPropertyName The other property name * * @return The Criterion * * @see PropertyExpression */
public static PropertyExpression leProperty(String propertyName, String otherPropertyName) { return new PropertyExpression( propertyName, otherPropertyName, "<=" ); }
Apply a "greater than" constraint to two properties
Params:
  • propertyName – One property name
  • otherPropertyName – The other property name
See Also:
Returns:The Criterion
/** * Apply a "greater than" constraint to two properties * * @param propertyName One property name * @param otherPropertyName The other property name * * @return The Criterion * * @see PropertyExpression */
public static PropertyExpression gtProperty(String propertyName, String otherPropertyName) { return new PropertyExpression( propertyName, otherPropertyName, ">" ); }
Apply a "greater than or equal" constraint to two properties
Params:
  • propertyName – One property name
  • otherPropertyName – The other property name
See Also:
Returns:The Criterion
/** * Apply a "greater than or equal" constraint to two properties * * @param propertyName One property name * @param otherPropertyName The other property name * * @return The Criterion * * @see PropertyExpression */
public static PropertyExpression geProperty(String propertyName, String otherPropertyName) { return new PropertyExpression( propertyName, otherPropertyName, ">=" ); }
Return the conjuction of two expressions
Params:
  • lhs – One expression
  • rhs – The other expression
Returns:The Criterion
/** * Return the conjuction of two expressions * * @param lhs One expression * @param rhs The other expression * * @return The Criterion */
public static LogicalExpression and(Criterion lhs, Criterion rhs) { return new LogicalExpression(lhs, rhs, "and"); }
Return the conjuction of multiple expressions
Params:
  • predicates – The predicates making up the initial junction
Returns:The conjunction
/** * Return the conjuction of multiple expressions * * @param predicates The predicates making up the initial junction * * @return The conjunction */
public static Conjunction and(Criterion... predicates) { return conjunction( predicates ); }
Return the disjuction of two expressions
Params:
  • lhs – One expression
  • rhs – The other expression
Returns:The Criterion
/** * Return the disjuction of two expressions * * @param lhs One expression * @param rhs The other expression * * @return The Criterion */
public static LogicalExpression or(Criterion lhs, Criterion rhs) { return new LogicalExpression( lhs, rhs, "or" ); }
Return the disjuction of multiple expressions
Params:
  • predicates – The predicates making up the initial junction
Returns:The conjunction
/** * Return the disjuction of multiple expressions * * @param predicates The predicates making up the initial junction * * @return The conjunction */
public static Disjunction or(Criterion... predicates) { return disjunction( predicates ); }
Return the negation of an expression
Params:
  • expression – The expression to be negated
See Also:
Returns:Criterion
/** * Return the negation of an expression * * @param expression The expression to be negated * * @return Criterion * * @see NotExpression */
public static Criterion not(Criterion expression) { return new NotExpression( expression ); }
Create a restriction expressed in SQL with JDBC parameters. Any occurrences of {alias} will be replaced by the table alias.
Params:
  • sql – The SQL restriction
  • values – The parameter values
  • types – The parameter types
See Also:
Returns:The Criterion
/** * Create a restriction expressed in SQL with JDBC parameters. Any occurrences of <tt>{alias}</tt> will be * replaced by the table alias. * * @param sql The SQL restriction * @param values The parameter values * @param types The parameter types * * @return The Criterion * * @see SQLCriterion */
public static Criterion sqlRestriction(String sql, Object[] values, Type[] types) { return new SQLCriterion( sql, values, types ); }
Create a restriction expressed in SQL with one JDBC parameter. Any occurrences of {alias} will be replaced by the table alias.
Params:
  • sql – The SQL restriction
  • value – The parameter value
  • type – The parameter type
See Also:
Returns:The Criterion
/** * Create a restriction expressed in SQL with one JDBC parameter. Any occurrences of <tt>{alias}</tt> will be * replaced by the table alias. * * @param sql The SQL restriction * @param value The parameter value * @param type The parameter type * * @return The Criterion * * @see SQLCriterion */
public static Criterion sqlRestriction(String sql, Object value, Type type) { return new SQLCriterion( sql, value, type ); }
Apply a constraint expressed in SQL with no JDBC parameters. Any occurrences of {alias} will be replaced by the table alias.
Params:
  • sql – The SQL restriction
See Also:
Returns:The Criterion
/** * Apply a constraint expressed in SQL with no JDBC parameters. Any occurrences of <tt>{alias}</tt> will be * replaced by the table alias. * * @param sql The SQL restriction * * @return The Criterion * * @see SQLCriterion */
public static Criterion sqlRestriction(String sql) { return new SQLCriterion( sql ); }
Group expressions together in a single conjunction (A and B and C...). This form creates an empty conjunction. See Junction.add(Criterion)
Returns:Conjunction
/** * Group expressions together in a single conjunction (A and B and C...). * * This form creates an empty conjunction. See {@link Conjunction#add(Criterion)} * * @return Conjunction */
public static Conjunction conjunction() { return new Conjunction(); }
Group expressions together in a single conjunction (A and B and C...).
Params:
  • conditions – The initial set of conditions to put into the Conjunction
Returns:Conjunction
/** * Group expressions together in a single conjunction (A and B and C...). * * @param conditions The initial set of conditions to put into the Conjunction * * @return Conjunction */
public static Conjunction conjunction(Criterion... conditions) { return new Conjunction( conditions ); }
Group expressions together in a single disjunction (A or B or C...). This form creates an empty disjunction. See Junction.add(Criterion)
Returns:Conjunction
/** * Group expressions together in a single disjunction (A or B or C...). * * This form creates an empty disjunction. See {@link Disjunction#add(Criterion)} * * @return Conjunction */
public static Disjunction disjunction() { return new Disjunction(); }
Group expressions together in a single disjunction (A or B or C...).
Params:
  • conditions – The initial set of conditions to put into the Disjunction
Returns:Conjunction
/** * Group expressions together in a single disjunction (A or B or C...). * * @param conditions The initial set of conditions to put into the Disjunction * * @return Conjunction */
public static Disjunction disjunction(Criterion... conditions) { return new Disjunction( conditions ); }
Apply an "equals" constraint to each property in the key set of a Map
Params:
  • propertyNameValues – a map from property names to values
See Also:
Returns:Criterion
/** * Apply an "equals" constraint to each property in the key set of a <tt>Map</tt> * * @param propertyNameValues a map from property names to values * * @return Criterion * * @see Conjunction */
@SuppressWarnings("UnusedDeclaration") public static Criterion allEq(Map<String,?> propertyNameValues) { final Conjunction conj = conjunction(); for ( Map.Entry<String,?> entry : propertyNameValues.entrySet() ) { conj.add( eq( entry.getKey(), entry.getValue() ) ); } return conj; }
Constrain a collection valued property to be empty
Params:
  • propertyName – The name of the collection property
See Also:
Returns:The Criterion
/** * Constrain a collection valued property to be empty * * @param propertyName The name of the collection property * * @return The Criterion * * @see EmptyExpression */
public static Criterion isEmpty(String propertyName) { return new EmptyExpression( propertyName ); }
Constrain a collection valued property to be non-empty
Params:
  • propertyName – The name of the collection property
See Also:
Returns:The Criterion
/** * Constrain a collection valued property to be non-empty * * @param propertyName The name of the collection property * * @return The Criterion * * @see NotEmptyExpression */
public static Criterion isNotEmpty(String propertyName) { return new NotEmptyExpression( propertyName ); }
Constrain a collection valued property by size
Params:
  • propertyName – The name of the collection property
  • size – The size to use in comparison
See Also:
Returns:The Criterion
/** * Constrain a collection valued property by size * * @param propertyName The name of the collection property * @param size The size to use in comparison * * @return The Criterion * * @see SizeExpression */
public static Criterion sizeEq(String propertyName, int size) { return new SizeExpression( propertyName, size, "=" ); }
Constrain a collection valued property by size
Params:
  • propertyName – The name of the collection property
  • size – The size to use in comparison
See Also:
Returns:The Criterion
/** * Constrain a collection valued property by size * * @param propertyName The name of the collection property * @param size The size to use in comparison * * @return The Criterion * * @see SizeExpression */
@SuppressWarnings("UnusedDeclaration") public static Criterion sizeNe(String propertyName, int size) { return new SizeExpression( propertyName, size, "<>" ); }
Constrain a collection valued property by size
Params:
  • propertyName – The name of the collection property
  • size – The size to use in comparison
See Also:
Returns:The Criterion
/** * Constrain a collection valued property by size * * @param propertyName The name of the collection property * @param size The size to use in comparison * * @return The Criterion * * @see SizeExpression */
@SuppressWarnings("UnusedDeclaration") public static Criterion sizeGt(String propertyName, int size) { return new SizeExpression( propertyName, size, "<" ); }
Constrain a collection valued property by size
Params:
  • propertyName – The name of the collection property
  • size – The size to use in comparison
See Also:
Returns:The Criterion
/** * Constrain a collection valued property by size * * @param propertyName The name of the collection property * @param size The size to use in comparison * * @return The Criterion * * @see SizeExpression */
@SuppressWarnings("UnusedDeclaration") public static Criterion sizeLt(String propertyName, int size) { return new SizeExpression( propertyName, size, ">" ); }
Constrain a collection valued property by size
Params:
  • propertyName – The name of the collection property
  • size – The size to use in comparison
See Also:
Returns:The Criterion
/** * Constrain a collection valued property by size * * @param propertyName The name of the collection property * @param size The size to use in comparison * * @return The Criterion * * @see SizeExpression */
@SuppressWarnings("UnusedDeclaration") public static Criterion sizeGe(String propertyName, int size) { return new SizeExpression( propertyName, size, "<=" ); }
Constrain a collection valued property by size
Params:
  • propertyName – The name of the collection property
  • size – The size to use in comparison
See Also:
Returns:The Criterion
/** * Constrain a collection valued property by size * * @param propertyName The name of the collection property * @param size The size to use in comparison * * @return The Criterion * * @see SizeExpression */
@SuppressWarnings("UnusedDeclaration") public static Criterion sizeLe(String propertyName, int size) { return new SizeExpression( propertyName, size, ">=" ); }
Consider using any of the natural id based loading stuff from session instead, especially in cases where the restriction is the full set of natural id values.
See Also:
Returns:The Criterion
/** * Consider using any of the natural id based loading stuff from session instead, especially in cases * where the restriction is the full set of natural id values. * * @return The Criterion * * @see NaturalIdentifier * * @see org.hibernate.Session#byNaturalId(Class) * @see org.hibernate.Session#byNaturalId(String) * @see org.hibernate.Session#bySimpleNaturalId(Class) * @see org.hibernate.Session#bySimpleNaturalId(String) */
public static NaturalIdentifier naturalId() { return new NaturalIdentifier(); } protected Restrictions() { // cannot be instantiated, but needs to be protected so Expression can extend it } }