/*
 * 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;

import java.util.List;

import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.sql.JoinType;
import org.hibernate.transform.ResultTransformer;


Criteria is a simplified API for retrieving entities by composing Criterion objects. This is a very convenient approach for functionality like "search" screens where there is a variable number of conditions to be placed upon the result set.

The Session is a factory for Criteria. Criterion instances are usually obtained via the factory methods on Restrictions. eg.
List cats = session.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Iz%") )
    .add( Restrictions.gt( "weight", new Float(minWeight) ) )
    .addOrder( Order.asc("age") )
    .list();
You may navigate associations using createAlias() or createCriteria().
List cats = session.createCriteria(Cat.class)
    .createCriteria("kittens")
        .add( Restrictions.like("name", "Iz%") )
    .list();
List cats = session.createCriteria(Cat.class)
    .createAlias("kittens", "kit")
    .add( Restrictions.like("kit.name", "Iz%") )
    .list();
You may specify projection and aggregation using Projection instances obtained via the factory methods on Projections.
List cats = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount() )
        .add( Projections.avg("weight") )
        .add( Projections.max("weight") )
        .add( Projections.min("weight") )
        .add( Projections.groupProperty("color") )
    )
    .addOrder( Order.asc("color") )
    .list();
Author:Gavin King
See Also:
/** * <tt>Criteria</tt> is a simplified API for retrieving entities * by composing <tt>Criterion</tt> objects. This is a very * convenient approach for functionality like "search" screens * where there is a variable number of conditions to be placed * upon the result set.<br> * <br> * The <tt>Session</tt> is a factory for <tt>Criteria</tt>. * <tt>Criterion</tt> instances are usually obtained via * the factory methods on <tt>Restrictions</tt>. eg. * <pre> * List cats = session.createCriteria(Cat.class) * .add( Restrictions.like("name", "Iz%") ) * .add( Restrictions.gt( "weight", new Float(minWeight) ) ) * .addOrder( Order.asc("age") ) * .list(); * </pre> * You may navigate associations using <tt>createAlias()</tt> or * <tt>createCriteria()</tt>. * <pre> * List cats = session.createCriteria(Cat.class) * .createCriteria("kittens") * .add( Restrictions.like("name", "Iz%") ) * .list(); * </pre> * <pre> * List cats = session.createCriteria(Cat.class) * .createAlias("kittens", "kit") * .add( Restrictions.like("kit.name", "Iz%") ) * .list(); * </pre> * You may specify projection and aggregation using <tt>Projection</tt> * instances obtained via the factory methods on <tt>Projections</tt>. * <pre> * List cats = session.createCriteria(Cat.class) * .setProjection( Projections.projectionList() * .add( Projections.rowCount() ) * .add( Projections.avg("weight") ) * .add( Projections.max("weight") ) * .add( Projections.min("weight") ) * .add( Projections.groupProperty("color") ) * ) * .addOrder( Order.asc("color") ) * .list(); * </pre> * * @see Session#createCriteria(java.lang.Class) * @see org.hibernate.criterion.Restrictions * @see org.hibernate.criterion.Projections * @see org.hibernate.criterion.Order * @see org.hibernate.criterion.Criterion * @see org.hibernate.criterion.Projection * @see org.hibernate.criterion.DetachedCriteria a disconnected version of this API * @author Gavin King */
public interface Criteria extends CriteriaSpecification {
Get the alias of the entity encapsulated by this criteria instance.
Returns:The alias for the encapsulated entity.
/** * Get the alias of the entity encapsulated by this criteria instance. * * @return The alias for the encapsulated entity. */
public String getAlias();
Used to specify that the query results will be a projection (scalar in nature). Implicitly specifies the CriteriaSpecification.PROJECTION result transformer.

The individual components contained within the given projection determines the overall "shape" of the query result.
Params:
  • projection – The projection representing the overall "shape" of the query results.
Returns:this (for method chaining)
/** * Used to specify that the query results will be a projection (scalar in * nature). Implicitly specifies the {@link #PROJECTION} result transformer. * <p/> * The individual components contained within the given * {@link Projection projection} determines the overall "shape" of the * query result. * * @param projection The projection representing the overall "shape" of the * query results. * @return this (for method chaining) */
public Criteria setProjection(Projection projection);
Add a restriction to constrain the results to be retrieved.
Params:
  • criterion – The criterion object representing the restriction to be applied.
Returns:this (for method chaining)
/** * Add a {@link Criterion restriction} to constrain the results to be * retrieved. * * @param criterion The {@link Criterion criterion} object representing the * restriction to be applied. * @return this (for method chaining) */
public Criteria add(Criterion criterion);
Add an ordering to the result set.
Params:
  • order – The order object representing an ordering to be applied to the results.
Returns:this (for method chaining)
/** * Add an {@link Order ordering} to the result set. * * @param order The {@link Order order} object representing an ordering * to be applied to the results. * @return this (for method chaining) */
public Criteria addOrder(Order order);
Specify an association fetching strategy for an association or a collection of values.
Params:
  • associationPath – a dot separated property path
  • mode – The fetch mode for the referenced association
Throws:
Returns:this (for method chaining)
/** * Specify an association fetching strategy for an association or a * collection of values. * * @param associationPath a dot separated property path * @param mode The fetch mode for the referenced association * * @return this (for method chaining) * * @throws HibernateException Indicates a problem applying the given fetch mode */
public Criteria setFetchMode(String associationPath, FetchMode mode) throws HibernateException;
Set the lock mode of the current entity.
Params:
  • lockMode – The lock mode to be applied
Returns:this (for method chaining)
/** * Set the lock mode of the current entity. * * @param lockMode The lock mode to be applied * * @return this (for method chaining) */
public Criteria setLockMode(LockMode lockMode);
Set the lock mode of the aliased entity.
Params:
  • alias – The previously assigned alias representing the entity to which the given lock mode should apply.
  • lockMode – The lock mode to be applied
Returns:this (for method chaining)
/** * Set the lock mode of the aliased entity. * * @param alias The previously assigned alias representing the entity to * which the given lock mode should apply. * @param lockMode The lock mode to be applied * * @return this (for method chaining) */
public Criteria setLockMode(String alias, LockMode lockMode);
Join an association, assigning an alias to the joined association.

Functionally equivalent to createAlias(String, String, JoinType) using JoinType.INNER_JOIN for the joinType.
Params:
  • associationPath – A dot-separated property path
  • alias – The alias to assign to the joined association (for later reference).
Throws:
Returns:this (for method chaining)
/** * Join an association, assigning an alias to the joined association. * <p/> * Functionally equivalent to {@link #createAlias(String, String, JoinType )} using * {@link JoinType#INNER_JOIN} for the joinType. * * @param associationPath A dot-separated property path * @param alias The alias to assign to the joined association (for later reference). * * @return this (for method chaining) * * @throws HibernateException Indicates a problem creating the sub criteria */
public Criteria createAlias(String associationPath, String alias) throws HibernateException;
Join an association using the specified join-type, assigning an alias to the joined association.

The joinType is expected to be one of JoinType.INNER_JOIN (the default), JoinType.FULL_JOIN, or JoinType.LEFT_OUTER_JOIN.
Params:
  • associationPath – A dot-separated property path
  • alias – The alias to assign to the joined association (for later reference).
  • joinType – The type of join to use.
Throws:
Returns:this (for method chaining)
/** * Join an association using the specified join-type, assigning an alias * to the joined association. * <p/> * The joinType is expected to be one of {@link JoinType#INNER_JOIN} (the default), * {@link JoinType#FULL_JOIN}, or {@link JoinType#LEFT_OUTER_JOIN}. * * @param associationPath A dot-separated property path * @param alias The alias to assign to the joined association (for later reference). * @param joinType The type of join to use. * * @return this (for method chaining) * * @throws HibernateException Indicates a problem creating the sub criteria */
public Criteria createAlias(String associationPath, String alias, JoinType joinType) throws HibernateException;
Join an association using the specified join-type, assigning an alias to the joined association.

The joinType is expected to be one of CriteriaSpecification.INNER_JOIN (the default), CriteriaSpecification.FULL_JOIN, or CriteriaSpecification.LEFT_JOIN.
Params:
  • associationPath – A dot-separated property path
  • alias – The alias to assign to the joined association (for later reference).
  • joinType – The type of join to use.
Throws:
Returns:this (for method chaining)
Deprecated:use createAlias(String, String, JoinType)
/** * Join an association using the specified join-type, assigning an alias * to the joined association. * <p/> * The joinType is expected to be one of {@link #INNER_JOIN} (the default), * {@link #FULL_JOIN}, or {@link #LEFT_JOIN}. * * @param associationPath A dot-separated property path * @param alias The alias to assign to the joined association (for later reference). * @param joinType The type of join to use. * * @return this (for method chaining) * * @throws HibernateException Indicates a problem creating the sub criteria * @deprecated use {@link #createAlias(String, String, org.hibernate.sql.JoinType)} */
@Deprecated public Criteria createAlias(String associationPath, String alias, int joinType) throws HibernateException;
Join an association using the specified join-type, assigning an alias to the joined association.

The joinType is expected to be one of JoinType.INNER_JOIN (the default), JoinType.FULL_JOIN, or JoinType.LEFT_OUTER_JOIN.
Params:
  • associationPath – A dot-separated property path
  • alias – The alias to assign to the joined association (for later reference).
  • joinType – The type of join to use.
  • withClause – The criteria to be added to the join condition (ON clause)
Throws:
Returns:this (for method chaining)
/** * Join an association using the specified join-type, assigning an alias * to the joined association. * <p/> * The joinType is expected to be one of {@link JoinType#INNER_JOIN} (the default), * {@link JoinType#FULL_JOIN}, or {@link JoinType#LEFT_OUTER_JOIN}. * * @param associationPath A dot-separated property path * @param alias The alias to assign to the joined association (for later reference). * @param joinType The type of join to use. * @param withClause The criteria to be added to the join condition (<tt>ON</tt> clause) * * @return this (for method chaining) * * @throws HibernateException Indicates a problem creating the sub criteria */
public Criteria createAlias(String associationPath, String alias, JoinType joinType, Criterion withClause) throws HibernateException;
Join an association using the specified join-type, assigning an alias to the joined association.

The joinType is expected to be one of CriteriaSpecification.INNER_JOIN (the default), CriteriaSpecification.FULL_JOIN, or CriteriaSpecification.LEFT_JOIN.
Params:
  • associationPath – A dot-separated property path
  • alias – The alias to assign to the joined association (for later reference).
  • joinType – The type of join to use.
  • withClause – The criteria to be added to the join condition (ON clause)
Throws:
Returns:this (for method chaining)
Deprecated:use createAlias(String, String, JoinType, Criterion)
/** * Join an association using the specified join-type, assigning an alias * to the joined association. * <p/> * The joinType is expected to be one of {@link #INNER_JOIN} (the default), * {@link #FULL_JOIN}, or {@link #LEFT_JOIN}. * * @param associationPath A dot-separated property path * @param alias The alias to assign to the joined association (for later reference). * @param joinType The type of join to use. * @param withClause The criteria to be added to the join condition (<tt>ON</tt> clause) * * @return this (for method chaining) * * @throws HibernateException Indicates a problem creating the sub criteria * @deprecated use {@link #createAlias(String, String, JoinType, Criterion)} */
@Deprecated public Criteria createAlias(String associationPath, String alias, int joinType, Criterion withClause) throws HibernateException;
Create a new Criteria, "rooted" at the associated entity.

Functionally equivalent to createCriteria(String, JoinType) using JoinType.INNER_JOIN for the joinType.
Params:
  • associationPath – A dot-separated property path
Throws:
Returns:the created "sub criteria"
/** * Create a new <tt>Criteria</tt>, "rooted" at the associated entity. * <p/> * Functionally equivalent to {@link #createCriteria(String, org.hibernate.sql.JoinType)} using * {@link JoinType#INNER_JOIN} for the joinType. * * @param associationPath A dot-separated property path * * @return the created "sub criteria" * * @throws HibernateException Indicates a problem creating the sub criteria */
public Criteria createCriteria(String associationPath) throws HibernateException;
Create a new Criteria, "rooted" at the associated entity, using the specified join type.
Params:
  • associationPath – A dot-separated property path
  • joinType – The type of join to use.
Throws:
Returns:the created "sub criteria"
/** * Create a new <tt>Criteria</tt>, "rooted" at the associated entity, using the * specified join type. * * @param associationPath A dot-separated property path * @param joinType The type of join to use. * * @return the created "sub criteria" * * @throws HibernateException Indicates a problem creating the sub criteria */
public Criteria createCriteria(String associationPath, JoinType joinType) throws HibernateException;
Create a new Criteria, "rooted" at the associated entity, using the specified join type.
Params:
  • associationPath – A dot-separated property path
  • joinType – The type of join to use.
Throws:
Returns:the created "sub criteria"
Deprecated:use createAlias(String, String, JoinType)
/** * Create a new <tt>Criteria</tt>, "rooted" at the associated entity, using the * specified join type. * * @param associationPath A dot-separated property path * @param joinType The type of join to use. * * @return the created "sub criteria" * * @throws HibernateException Indicates a problem creating the sub criteria * @deprecated use {@link #createAlias(String, String, org.hibernate.sql.JoinType)} */
@Deprecated public Criteria createCriteria(String associationPath, int joinType) throws HibernateException;
Create a new Criteria, "rooted" at the associated entity, assigning the given alias.

Functionally equivalent to createCriteria(String, String, JoinType) using JoinType.INNER_JOIN for the joinType.
Params:
  • associationPath – A dot-separated property path
  • alias – The alias to assign to the joined association (for later reference).
Throws:
Returns:the created "sub criteria"
/** * Create a new <tt>Criteria</tt>, "rooted" at the associated entity, * assigning the given alias. * <p/> * Functionally equivalent to {@link #createCriteria(String, String, org.hibernate.sql.JoinType)} using * {@link JoinType#INNER_JOIN} for the joinType. * * @param associationPath A dot-separated property path * @param alias The alias to assign to the joined association (for later reference). * * @return the created "sub criteria" * * @throws HibernateException Indicates a problem creating the sub criteria */
public Criteria createCriteria(String associationPath, String alias) throws HibernateException;
Create a new Criteria, "rooted" at the associated entity, assigning the given alias and using the specified join type.
Params:
  • associationPath – A dot-separated property path
  • alias – The alias to assign to the joined association (for later reference).
  • joinType – The type of join to use.
Throws:
Returns:the created "sub criteria"
/** * Create a new <tt>Criteria</tt>, "rooted" at the associated entity, * assigning the given alias and using the specified join type. * * @param associationPath A dot-separated property path * @param alias The alias to assign to the joined association (for later reference). * @param joinType The type of join to use. * * @return the created "sub criteria" * * @throws HibernateException Indicates a problem creating the sub criteria */
public Criteria createCriteria(String associationPath, String alias, JoinType joinType) throws HibernateException;
Create a new Criteria, "rooted" at the associated entity, assigning the given alias and using the specified join type.
Params:
  • associationPath – A dot-separated property path
  • alias – The alias to assign to the joined association (for later reference).
  • joinType – The type of join to use.
Throws:
Returns:the created "sub criteria"
Deprecated:use createCriteria(String, JoinType)
/** * Create a new <tt>Criteria</tt>, "rooted" at the associated entity, * assigning the given alias and using the specified join type. * * @param associationPath A dot-separated property path * @param alias The alias to assign to the joined association (for later reference). * @param joinType The type of join to use. * * @return the created "sub criteria" * * @throws HibernateException Indicates a problem creating the sub criteria * @deprecated use {@link #createCriteria(String, org.hibernate.sql.JoinType)} */
@Deprecated public Criteria createCriteria(String associationPath, String alias, int joinType) throws HibernateException;
Create a new Criteria, "rooted" at the associated entity, assigning the given alias and using the specified join type.
Params:
  • associationPath – A dot-separated property path
  • alias – The alias to assign to the joined association (for later reference).
  • joinType – The type of join to use.
  • withClause – The criteria to be added to the join condition (ON clause)
Throws:
Returns:the created "sub criteria"
/** * Create a new <tt>Criteria</tt>, "rooted" at the associated entity, * assigning the given alias and using the specified join type. * * @param associationPath A dot-separated property path * @param alias The alias to assign to the joined association (for later reference). * @param joinType The type of join to use. * @param withClause The criteria to be added to the join condition (<tt>ON</tt> clause) * * @return the created "sub criteria" * * @throws HibernateException Indicates a problem creating the sub criteria */
public Criteria createCriteria(String associationPath, String alias, JoinType joinType, Criterion withClause) throws HibernateException;
Create a new Criteria, "rooted" at the associated entity, assigning the given alias and using the specified join type.
Params:
  • associationPath – A dot-separated property path
  • alias – The alias to assign to the joined association (for later reference).
  • joinType – The type of join to use.
  • withClause – The criteria to be added to the join condition (ON clause)
Throws:
Returns:the created "sub criteria"
Deprecated:use createCriteria(String, String, JoinType, Criterion)
/** * Create a new <tt>Criteria</tt>, "rooted" at the associated entity, * assigning the given alias and using the specified join type. * * @param associationPath A dot-separated property path * @param alias The alias to assign to the joined association (for later reference). * @param joinType The type of join to use. * @param withClause The criteria to be added to the join condition (<tt>ON</tt> clause) * * @return the created "sub criteria" * * @throws HibernateException Indicates a problem creating the sub criteria * @deprecated use {@link #createCriteria(String, String, org.hibernate.sql.JoinType, org.hibernate.criterion.Criterion)} */
@Deprecated public Criteria createCriteria(String associationPath, String alias, int joinType, Criterion withClause) throws HibernateException;
Set a strategy for handling the query results. This determines the "shape" of the query result.
Params:
  • resultTransformer – The transformer to apply
See Also:
Returns:this (for method chaining)
/** * Set a strategy for handling the query results. This determines the * "shape" of the query result. * * @param resultTransformer The transformer to apply * @return this (for method chaining) * * @see #ROOT_ENTITY * @see #DISTINCT_ROOT_ENTITY * @see #ALIAS_TO_ENTITY_MAP * @see #PROJECTION */
public Criteria setResultTransformer(ResultTransformer resultTransformer);
Set a limit upon the number of objects to be retrieved.
Params:
  • maxResults – the maximum number of results
Returns:this (for method chaining)
/** * Set a limit upon the number of objects to be retrieved. * * @param maxResults the maximum number of results * @return this (for method chaining) */
public Criteria setMaxResults(int maxResults);
Set the first result to be retrieved.
Params:
  • firstResult – the first result to retrieve, numbered from 0
Returns:this (for method chaining)
/** * Set the first result to be retrieved. * * @param firstResult the first result to retrieve, numbered from <tt>0</tt> * @return this (for method chaining) */
public Criteria setFirstResult(int firstResult);
Was the read-only/modifiable mode explicitly initialized?
See Also:
Returns:true, the read-only/modifiable mode was explicitly initialized; false, otherwise.
/** * Was the read-only/modifiable mode explicitly initialized? * * @return true, the read-only/modifiable mode was explicitly initialized; false, otherwise. * * @see Criteria#setReadOnly(boolean) */
public boolean isReadOnlyInitialized();
Should entities and proxies loaded by this Criteria be put in read-only mode? If the read-only/modifiable setting was not initialized, then the default read-only/modifiable setting for the persistence context is returned instead.
Throws:
  • IllegalStateException – if isReadOnlyInitialized() returns false and this Criteria is not associated with a session.
See Also:
Returns:true, entities and proxies loaded by the criteria will be put in read-only mode false, entities and proxies loaded by the criteria will be put in modifiable mode
/** * Should entities and proxies loaded by this Criteria be put in read-only mode? If the * read-only/modifiable setting was not initialized, then the default * read-only/modifiable setting for the persistence context is returned instead. * @see Criteria#setReadOnly(boolean) * @see org.hibernate.engine.spi.PersistenceContext#isDefaultReadOnly() * * The read-only/modifiable setting has no impact on entities/proxies returned by the * Criteria that existed in the session before the Criteria was executed. * * @return true, entities and proxies loaded by the criteria will be put in read-only mode * false, entities and proxies loaded by the criteria will be put in modifiable mode * @throws IllegalStateException if <code>isReadOnlyInitialized()</code> returns <code>false</code> * and this Criteria is not associated with a session. * @see Criteria#isReadOnlyInitialized() */
public boolean isReadOnly();
Set the read-only/modifiable mode for entities and proxies loaded by this Criteria. This setting overrides the default setting for the persistence context.
Params:
  • readOnly – true, entities and proxies loaded by the criteria will be put in read-only mode false, entities and proxies loaded by the criteria will be put in modifiable mode
See Also:
Returns:this, for method chaining
/** * Set the read-only/modifiable mode for entities and proxies * loaded by this Criteria. This setting overrides the default setting * for the persistence context. * @see org.hibernate.engine.spi.PersistenceContext#isDefaultReadOnly() * * To set the default read-only/modifiable setting used for * entities and proxies that are loaded into the session: * @see org.hibernate.engine.spi.PersistenceContext#setDefaultReadOnly(boolean) * @see org.hibernate.Session#setDefaultReadOnly(boolean) * * Read-only entities are not dirty-checked and snapshots of persistent * state are not maintained. Read-only entities can be modified, but * changes are not persisted. * * When a proxy is initialized, the loaded entity will have the same * read-only/modifiable setting as the uninitialized * proxy has, regardless of the session's current setting. * * The read-only/modifiable setting has no impact on entities/proxies * returned by the criteria that existed in the session before the criteria was executed. * * @param readOnly true, entities and proxies loaded by the criteria will be put in read-only mode * false, entities and proxies loaded by the criteria will be put in modifiable mode * @return {@code this}, for method chaining */
public Criteria setReadOnly(boolean readOnly);
Set a fetch size for the underlying JDBC query.
Params:
  • fetchSize – the fetch size
See Also:
Returns:this (for method chaining)
/** * Set a fetch size for the underlying JDBC query. * * @param fetchSize the fetch size * @return this (for method chaining) * * @see java.sql.Statement#setFetchSize */
public Criteria setFetchSize(int fetchSize);
Set a timeout for the underlying JDBC query.
Params:
  • timeout – The timeout value to apply.
See Also:
Returns:this (for method chaining)
/** * Set a timeout for the underlying JDBC query. * * @param timeout The timeout value to apply. * @return this (for method chaining) * * @see java.sql.Statement#setQueryTimeout */
public Criteria setTimeout(int timeout);
Enable caching of this query result, provided query caching is enabled for the underlying session factory.
Params:
  • cacheable – Should the result be considered cacheable; default is to not cache (false).
Returns:this (for method chaining)
/** * Enable caching of this query result, provided query caching is enabled * for the underlying session factory. * * @param cacheable Should the result be considered cacheable; default is * to not cache (false). * @return this (for method chaining) */
public Criteria setCacheable(boolean cacheable);
Set the name of the cache region to use for query result caching.
Params:
  • cacheRegion – the name of a query cache region, or null for the default query cache
See Also:
Returns:this (for method chaining)
/** * Set the name of the cache region to use for query result caching. * * @param cacheRegion the name of a query cache region, or <tt>null</tt> * for the default query cache * @return this (for method chaining) * * @see #setCacheable */
public Criteria setCacheRegion(String cacheRegion);
Add a comment to the generated SQL.
Params:
  • comment – a human-readable string
Returns:this (for method chaining)
/** * Add a comment to the generated SQL. * * @param comment a human-readable string * @return this (for method chaining) */
public Criteria setComment(String comment);
Add a DB query hint to the SQL. These differ from JPA's QueryHint, which is specific to the JPA implementation and ignores DB vendor-specific hints. Instead, these are intended solely for the vendor-specific hints, such as Oracle's optimizers. Multiple query hints are supported; the Dialect will determine concatenation and placement.
Params:
  • hint – The database specific query hint to add.
Returns:this (for method chaining)
/** * Add a DB query hint to the SQL. These differ from JPA's {@link javax.persistence.QueryHint}, which is specific * to the JPA implementation and ignores DB vendor-specific hints. Instead, these are intended solely for the * vendor-specific hints, such as Oracle's optimizers. Multiple query hints are supported; the Dialect will * determine concatenation and placement. * * @param hint The database specific query hint to add. * @return this (for method chaining) */
public Criteria addQueryHint(String hint);
Override the flush mode for this particular query.
Params:
  • flushMode – The flush mode to use.
Returns:this (for method chaining)
/** * Override the flush mode for this particular query. * * @param flushMode The flush mode to use. * @return this (for method chaining) */
public Criteria setFlushMode(FlushMode flushMode);
Override the cache mode for this particular query.
Params:
  • cacheMode – The cache mode to use.
Returns:this (for method chaining)
/** * Override the cache mode for this particular query. * * @param cacheMode The cache mode to use. * @return this (for method chaining) */
public Criteria setCacheMode(CacheMode cacheMode);
Get the results.
Throws:
  • HibernateException – Indicates a problem either translating the criteria to SQL, exeucting the SQL or processing the SQL results.
Returns:The list of matched query results.
/** * Get the results. * * @return The list of matched query results. * * @throws HibernateException Indicates a problem either translating the criteria to SQL, * exeucting the SQL or processing the SQL results. */
public List list() throws HibernateException;
Get the results as an instance of ScrollableResults.
Throws:
  • HibernateException – Indicates a problem either translating the criteria to SQL, exeucting the SQL or processing the SQL results.
Returns:The ScrollableResults representing the matched query results.
/** * Get the results as an instance of {@link ScrollableResults}. * * @return The {@link ScrollableResults} representing the matched * query results. * * @throws HibernateException Indicates a problem either translating the criteria to SQL, * exeucting the SQL or processing the SQL results. */
public ScrollableResults scroll() throws HibernateException;
Get the results as an instance of ScrollableResults based on the given scroll mode.
Params:
  • scrollMode – Indicates the type of underlying database cursor to request.
Throws:
  • HibernateException – Indicates a problem either translating the criteria to SQL, exeucting the SQL or processing the SQL results.
Returns:The ScrollableResults representing the matched query results.
/** * Get the results as an instance of {@link ScrollableResults} based on the * given scroll mode. * * @param scrollMode Indicates the type of underlying database cursor to * request. * * @return The {@link ScrollableResults} representing the matched * query results. * * @throws HibernateException Indicates a problem either translating the criteria to SQL, * exeucting the SQL or processing the SQL results. */
public ScrollableResults scroll(ScrollMode scrollMode) throws HibernateException;
Convenience method to return a single instance that matches the query, or null if the query returns no results.
Throws:
Returns:the single result or null
/** * Convenience method to return a single instance that matches * the query, or null if the query returns no results. * * @return the single result or <tt>null</tt> * @throws HibernateException if there is more than one matching result */
public Object uniqueResult() throws HibernateException; }