HibernateCriteriaBuilder (Grails 2.2.5)
Date: 2014-03-04

Overview | Package | Class | Deprecated | Index | Help
| Groovy Documentation
| FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## grails.orm
[Java] Class HibernateCriteriaBuilder

    java.lang.Object
      groovy.lang.GroovyObjectSupport
          grails.orm.HibernateCriteriaBuilder

All Implemented Interfaces:
  org.grails.datastore.mapping.query.api.Criteria, org.grails.datastore.mapping.query.api.ProjectionList

    public class HibernateCriteriaBuilder
    extends groovy.lang.GroovyObjectSupport

Wraps the Hibernate Criteria API in a builder. The builder can be retrieved through the "createCriteria()" dynamic static method of Grails domain classes (Example in Groovy):

             def c = Account.createCriteria()
             def results = c {
                 projections {
                     groupProperty("branch")
                 }
                 like("holderFirstName", "Fred%")
                 and {
                     between("balance", 500, 1000)
                     eq("branch", "London")
                 }
                 maxResults(10)
                 order("holderLastName", "desc")
             }

The builder can also be instantiated standalone with a SessionFactory and persistent Class instance:

          new HibernateCriteriaBuilder(clazz, sessionFactory).list {
             eq("firstName", "Fred")
          }

Authors:
  Graeme Rocher

Field Summary
`static java.lang.String` | `AND`
`static java.lang.String` | `BETWEEN`
`static org.hibernate.type.Type` | `BIG_DECIMAL`
`static org.hibernate.type.Type` | `BIG_INTEGER`
`static org.hibernate.type.Type` | `BINARY`
`static org.hibernate.type.Type` | `BLOB`
`static org.hibernate.type.Type` | `BOOLEAN`
`static org.hibernate.type.Type` | `BYTE`
`static org.hibernate.type.Type` | `CALENDAR`
`static org.hibernate.type.Type` | `CALENDAR_DATE`
`static org.hibernate.type.Type` | `CHARACTER`
`static org.hibernate.type.Type` | `CHARACTERS_CLOB`
`static org.hibernate.type.Type` | `CHARACTER_ARRAY`
`static org.hibernate.type.Type` | `CHAR_ARRAY`
`static org.hibernate.type.Type` | `CLASS`
`static org.hibernate.type.Type` | `CLOB`
`static org.hibernate.type.Type` | `CURRENCY`
`static org.hibernate.type.Type` | `DATE`
`static org.hibernate.type.Type` | `DOUBLE`
`static java.lang.String` | `EQUALS`
`static java.lang.String` | `EQUALS_PROPERTY`
`static org.hibernate.type.Type` | `FLOAT`
`static java.lang.String` | `GREATER_THAN`
`static java.lang.String` | `GREATER_THAN_OR_EQUAL`
`static java.lang.String` | `GREATER_THAN_OR_EQUAL_PROPERTY`
`static java.lang.String` | `GREATER_THAN_PROPERTY`
`static java.lang.String` | `ID_EQUALS`
`static java.lang.String` | `ILIKE`
`static org.hibernate.type.Type` | `IMAGE`
`static java.lang.String` | `IN`
`static org.hibernate.type.Type` | `INTEGER`
`static java.lang.String` | `IS_EMPTY`
`static java.lang.String` | `IS_NOT_EMPTY`
`static java.lang.String` | `IS_NOT_NULL`
`static java.lang.String` | `IS_NULL`
`static java.lang.String` | `LESS_THAN`
`static java.lang.String` | `LESS_THAN_OR_EQUAL`
`static java.lang.String` | `LESS_THAN_OR_EQUAL_PROPERTY`
`static java.lang.String` | `LESS_THAN_PROPERTY`
`static java.lang.String` | `LIKE`
`static org.hibernate.type.Type` | `LOCALE`
`static org.hibernate.type.Type` | `LONG`
`static org.hibernate.type.Type` | `MATERIALIZED_BLOB`
`static org.hibernate.type.Type` | `MATERIALIZED_CLOB`
`static java.lang.String` | `NOT`
`static java.lang.String` | `NOT_EQUAL`
`static java.lang.String` | `NOT_EQUAL_PROPERTY`
`static org.hibernate.type.Type` | `NUMERIC_BOOLEAN`
`static java.lang.String` | `OR`
`static java.lang.String` | `ORDER_ASCENDING`
`static java.lang.String` | `ORDER_DESCENDING`
`static java.lang.String` | `RLIKE`
`static org.hibernate.type.Type` | `SERIALIZABLE`
`static org.hibernate.type.Type` | `SHORT`
`static java.lang.String` | `SIZE_EQUALS`
`static org.hibernate.type.Type` | `STRING`
`static org.hibernate.type.Type` | `TEXT`
`static org.hibernate.type.Type` | `TIME`
`static org.hibernate.type.Type` | `TIMESTAMP`
`static org.hibernate.type.Type` | `TIMEZONE`
`static org.hibernate.type.Type` | `TRUE_FALSE`
`static org.hibernate.type.Type` | `URL`
`static org.hibernate.type.Type` | `UUID_BINARY`
`static org.hibernate.type.Type` | `UUID_CHAR`
`static org.hibernate.type.Type` | `WRAPPER_BINARY`
`static org.hibernate.type.Type` | `WRAPPER_CHARACTERS_CLOB`
`static org.hibernate.type.Type` | `WRAPPER_MATERIALIZED_BLOB`
`static org.hibernate.type.Type` | `YES_NO`

Constructor Summary
`HibernateCriteriaBuilder(java.lang.Class targetClass, org.hibernate.SessionFactory sessionFactory)`
`HibernateCriteriaBuilder(java.lang.Class targetClass, org.hibernate.SessionFactory sessionFactory, boolean uniqueResult)`

Method Summary
`protected void` | `addProjectionToList(org.hibernate.criterion.Projection propertyProjection, java.lang.String alias)`
`org.grails.datastore.mapping.query.api.ProjectionList` | `avg(java.lang.String propertyName)` Use a join query
`org.grails.datastore.mapping.query.api.ProjectionList` | `avg(java.lang.String propertyName, java.lang.String alias)`
`org.grails.datastore.mapping.query.api.Criteria` | `between(java.lang.String propertyName, java.lang.Object lo, java.lang.Object hi)`
`org.hibernate.Criteria` | `buildCriteria(groovy.lang.Closure criteriaClosure)` Throws a runtime exception where necessary to ensure the session gets closed
`void` | `cache(boolean shouldCache)`
`void` | `count(java.lang.String propertyName)` Adds a projection that allows the criteria to return the property count
`void` | `count(java.lang.String propertyName, java.lang.String alias)`
`org.grails.datastore.mapping.query.api.ProjectionList` | `count()`
`org.grails.datastore.mapping.query.api.ProjectionList` | `countDistinct(java.lang.String propertyName)` Adds a projection that allows the criteria's result to be grouped by a property
`org.grails.datastore.mapping.query.api.ProjectionList` | `countDistinct(java.lang.String propertyName, java.lang.String alias)`
`org.hibernate.Criteria` | `createAlias(java.lang.String associationPath, java.lang.String alias)`
`org.hibernate.Criteria` | `createAlias(java.lang.String associationPath, java.lang.String alias, int joinType)`
`org.grails.datastore.mapping.query.api.ProjectionList` | `distinct(java.lang.String propertyName)`
`org.grails.datastore.mapping.query.api.ProjectionList` | `distinct(java.lang.String propertyName, java.lang.String alias)` A distinct projection that takes a list
`org.grails.datastore.mapping.query.api.ProjectionList` | `distinct(java.util.Collection propertyNames)`
`org.grails.datastore.mapping.query.api.ProjectionList` | `distinct(java.util.Collection propertyNames, java.lang.String alias)` Adds a projection that allows the criteria to return the property average value
`org.grails.datastore.mapping.query.api.ProjectionList` | `distinct()`
`org.grails.datastore.mapping.query.api.Criteria` | `eq(java.lang.String propertyName, java.lang.Object propertyValue)`
`org.grails.datastore.mapping.query.api.Criteria` | `eq(java.util.Map params, java.lang.String propertyName, java.lang.Object propertyValue)`
`org.grails.datastore.mapping.query.api.Criteria` | `eq(java.lang.String propertyName, java.lang.Object propertyValue, java.util.Map params)`
`org.grails.datastore.mapping.query.api.Criteria` | `eqAll(java.lang.String propertyName, groovy.lang.Closure propertyValue)` Creates a subquery criterion that ensures the given property is less than all the given returned values
`org.grails.datastore.mapping.query.api.Criteria` | `eqAll(java.lang.String propertyName, org.grails.datastore.mapping.query.api.QueryableCriteria propertyValue)` Creates a subquery criterion that ensures the given property is less than all the given returned values
`org.grails.datastore.mapping.query.api.Criteria` | `eqProperty(java.lang.String propertyName, java.lang.String otherPropertyName)`
`void` | `fetchMode(java.lang.String associationPath, org.hibernate.FetchMode fetchMode)`
`org.grails.datastore.mapping.query.api.Criteria` | `ge(java.lang.String propertyName, java.lang.Object propertyValue)` Creates a "less than" Criterion based on the specified property name and value
`org.grails.datastore.mapping.query.api.Criteria` | `geAll(java.lang.String propertyName, groovy.lang.Closure propertyValue)` Creates a subquery criterion that ensures the given property is equal to all the given returned values
`org.grails.datastore.mapping.query.api.Criteria` | `geAll(java.lang.String propertyName, org.grails.datastore.mapping.query.api.QueryableCriteria propertyValue)`
`org.grails.datastore.mapping.query.api.Criteria` | `geProperty(java.lang.String propertyName, java.lang.String otherPropertyName)` Creates a Criterion that tests if the first property is less than the second property
`static org.hibernate.criterion.DetachedCriteria` | `getHibernateDetachedCriteria(org.grails.datastore.mapping.query.api.QueryableCriteria queryableCriteria)`
`org.hibernate.Criteria` | `getInstance()` A projection that selects a property name
`java.lang.Class` | `getTargetClass()`
`void` | `groupProperty(java.lang.String propertyName)` Adds a projection that allows the criteria to retrieve a maximum property value
`void` | `groupProperty(java.lang.String propertyName, java.lang.String alias)`
`org.grails.datastore.mapping.query.api.Criteria` | `gt(java.lang.String propertyName, java.lang.Object propertyValue)`
`org.grails.datastore.mapping.query.api.Criteria` | `gtAll(java.lang.String propertyName, groovy.lang.Closure propertyValue)` Creates a subquery criterion that ensures the given property is greater than all the given returned values
`org.grails.datastore.mapping.query.api.Criteria` | `gtAll(java.lang.String propertyName, org.grails.datastore.mapping.query.api.QueryableCriteria propertyValue)`
`org.grails.datastore.mapping.query.api.Criteria` | `gtProperty(java.lang.String propertyName, java.lang.String otherPropertyName)` Creates a Criterion that tests if the first property is greater than or equal to the second property
`org.grails.datastore.mapping.query.api.Criteria` | `gte(java.lang.String s, java.lang.Object o)`
`org.grails.datastore.mapping.query.api.ProjectionList` | `id()`
`org.grails.datastore.mapping.query.api.Criteria` | `idEq(java.lang.Object o)`
`org.grails.datastore.mapping.query.api.Criteria` | `idEquals(java.lang.Object o)`
`org.grails.datastore.mapping.query.api.Criteria` | `ilike(java.lang.String propertyName, java.lang.Object propertyValue)` Applys a "in" contrain on the specified property
`org.grails.datastore.mapping.query.api.Criteria` | `in(java.lang.String propertyName, java.util.Collection values)` Delegates to in as in is a Groovy keyword
`org.grails.datastore.mapping.query.api.Criteria` | `in(java.lang.String propertyName, java.lang.Object[] values)`
`org.grails.datastore.mapping.query.api.Criteria` | `inList(java.lang.String propertyName, java.util.Collection values)` Applys a "in" contrain on the specified property
`org.grails.datastore.mapping.query.api.Criteria` | `inList(java.lang.String propertyName, java.lang.Object[] values)`
`java.lang.Object` | `invokeMethod(java.lang.String name, java.lang.Object obj)`
`org.grails.datastore.mapping.query.api.Criteria` | `isEmpty(java.lang.String property)`
`org.grails.datastore.mapping.query.api.Criteria` | `isNotEmpty(java.lang.String property)`
`org.grails.datastore.mapping.query.api.Criteria` | `isNotNull(java.lang.String property)`
`org.grails.datastore.mapping.query.api.Criteria` | `isNull(java.lang.String property)`
`void` | `join(java.lang.String associationPath)`
`org.grails.datastore.mapping.query.api.Criteria` | `le(java.lang.String propertyName, java.lang.Object propertyValue)`
`org.grails.datastore.mapping.query.api.Criteria` | `leAll(java.lang.String propertyName, groovy.lang.Closure propertyValue)` Creates a subquery criterion that ensures the given property is greater than all the given returned values
`org.grails.datastore.mapping.query.api.Criteria` | `leAll(java.lang.String propertyName, org.grails.datastore.mapping.query.api.QueryableCriteria propertyValue)`
`org.grails.datastore.mapping.query.api.Criteria` | `leProperty(java.lang.String propertyName, java.lang.String otherPropertyName)` Creates a subquery criterion that ensures the given property is equal to all the given returned values
`org.grails.datastore.mapping.query.api.Criteria` | `like(java.lang.String propertyName, java.lang.Object propertyValue)` Creates a Criterion with from the specified property name and "rlike" (a regular expression version of "like") expression
`void` | `lock(boolean shouldLock)` Use a select query
`org.grails.datastore.mapping.query.api.Criteria` | `lt(java.lang.String propertyName, java.lang.Object propertyValue)` Creates a "less than or equal to" Criterion based on the specified property name and value
`org.grails.datastore.mapping.query.api.Criteria` | `ltAll(java.lang.String propertyName, groovy.lang.Closure propertyValue)` Creates a subquery criterion that ensures the given property is less than all the given returned values
`org.grails.datastore.mapping.query.api.Criteria` | `ltAll(java.lang.String propertyName, org.grails.datastore.mapping.query.api.QueryableCriteria propertyValue)`
`org.grails.datastore.mapping.query.api.Criteria` | `ltProperty(java.lang.String propertyName, java.lang.String otherPropertyName)` Creates a Criterion that tests if the first property is less than or equal to the second property
`org.grails.datastore.mapping.query.api.Criteria` | `lte(java.lang.String s, java.lang.Object o)`
`org.grails.datastore.mapping.query.api.ProjectionList` | `max(java.lang.String propertyName)` Adds a projection that allows the criteria to retrieve a minimum property value
`org.grails.datastore.mapping.query.api.ProjectionList` | `max(java.lang.String propertyName, java.lang.String alias)`
`org.grails.datastore.mapping.query.api.ProjectionList` | `min(java.lang.String propertyName)` Adds a projection that allows the criteria to return the row count
`org.grails.datastore.mapping.query.api.ProjectionList` | `min(java.lang.String propertyName, java.lang.String alias)`
`org.grails.datastore.mapping.query.api.Criteria` | `ne(java.lang.String propertyName, java.lang.Object propertyValue)` Creates a "between" Criterion based on the property name and specified lo and hi values
`org.grails.datastore.mapping.query.api.Criteria` | `neProperty(java.lang.String propertyName, java.lang.String otherPropertyName)` Creates a Criterion that tests if the first property is greater than the second property
`org.grails.datastore.mapping.query.api.Criteria` | `notEqual(java.lang.String propertyName, java.lang.Object propertyValue)`
`org.grails.datastore.mapping.query.api.Criteria` | `order(java.lang.String propertyName)` Orders by the specified property name (defaults to ascending)
`org.grails.datastore.mapping.query.api.Criteria` | `order(org.hibernate.criterion.Order o)` Orders by the specified property name and direction
`org.grails.datastore.mapping.query.api.Criteria` | `order(java.lang.String propertyName, java.lang.String direction)`
`org.grails.datastore.mapping.query.api.ProjectionList` | `property(java.lang.String propertyName)`
`org.grails.datastore.mapping.query.api.ProjectionList` | `property(java.lang.String propertyName, java.lang.String alias)`
`void` | `resultTransformer(org.hibernate.transform.ResultTransformer transformer)`
`org.grails.datastore.mapping.query.api.Criteria` | `rlike(java.lang.String propertyName, java.lang.Object propertyValue)` Creates a Criterion with from the specified property name and "ilike" (a case sensitive version of "like") expression
`org.grails.datastore.mapping.query.api.ProjectionList` | `rowCount()`
`org.grails.datastore.mapping.query.api.ProjectionList` | `rowCount(java.lang.String alias)`
`void` | `select(java.lang.String associationPath)` Whether to use the query cache
`void` | `setGrailsApplication(GrailsApplication grailsApplication)` A projection that selects a property name
`void` | `setUniqueResult(boolean uniqueResult)`
`org.grails.datastore.mapping.query.api.Criteria` | `sizeEq(java.lang.String propertyName, int size)` Creates a Criterion that contrains a collection property to be greater than the given size
`org.grails.datastore.mapping.query.api.Criteria` | `sizeGe(java.lang.String propertyName, int size)` Creates a Criterion that contrains a collection property to be less than or equal to the given size
`org.grails.datastore.mapping.query.api.Criteria` | `sizeGt(java.lang.String propertyName, int size)` Creates a Criterion that contrains a collection property to be greater than or equal to the given size
`org.grails.datastore.mapping.query.api.Criteria` | `sizeLe(java.lang.String propertyName, int size)` Creates a Criterion that contrains a collection property to be less than to the given size
`org.grails.datastore.mapping.query.api.Criteria` | `sizeLt(java.lang.String propertyName, int size)` Creates a Criterion that contrains a collection property to be not equal to the given size
`org.grails.datastore.mapping.query.api.Criteria` | `sizeNe(java.lang.String propertyName, int size)` Creates a "not equal" Criterion based on the specified property name and value
`protected void` | `sqlGroupProjection(java.lang.String sql, java.lang.String groupBy, java.util.List columnAliases, java.util.List types)`
`protected void` | `sqlProjection(java.lang.String sql, java.lang.String columnAlias, org.hibernate.type.Type type)` Adds a sql projection to the criteria
`protected void` | `sqlProjection(java.lang.String sql, java.util.List columnAliases, java.util.List types)` A projection that selects a distince property name
`org.grails.datastore.mapping.query.api.Criteria` | `sqlRestriction(java.lang.String sqlRestriction)` Applies a sql restriction to the results to allow something like:
           def results = Person.withCriteria {
               sqlRestriction "char_length(first_name) <= 4"
           }
`org.grails.datastore.mapping.query.api.Criteria` | `sqlRestriction(java.lang.String sqlRestriction, java.util.List values)`
`org.grails.datastore.mapping.query.api.ProjectionList` | `sum(java.lang.String propertyName)` Sets the fetch mode of an associated path
`org.grails.datastore.mapping.query.api.ProjectionList` | `sum(java.lang.String propertyName, java.lang.String alias)` Sets the resultTransformer.

Methods inherited from class groovy.lang.GroovyObjectSupport
groovy.lang.GroovyObjectSupport#getMetaClass(), groovy.lang.GroovyObjectSupport#setMetaClass(groovy.lang.MetaClass), groovy.lang.GroovyObjectSupport#setProperty(java.lang.String, java.lang.Object), groovy.lang.GroovyObjectSupport#getProperty(java.lang.String), groovy.lang.GroovyObjectSupport#invokeMethod(java.lang.String, java.lang.Object), groovy.lang.GroovyObjectSupport#wait(), groovy.lang.GroovyObjectSupport#wait(long, int), groovy.lang.GroovyObjectSupport#wait(long), groovy.lang.GroovyObjectSupport#equals(java.lang.Object), groovy.lang.GroovyObjectSupport#toString(), groovy.lang.GroovyObjectSupport#hashCode(), groovy.lang.GroovyObjectSupport#getClass(), groovy.lang.GroovyObjectSupport#notify(), groovy.lang.GroovyObjectSupport#notifyAll()

Methods inherited from class java.lang.Object
java.lang.Object#wait(), java.lang.Object#wait(long, int), java.lang.Object#wait(long), java.lang.Object#equals(java.lang.Object), java.lang.Object#toString(), java.lang.Object#hashCode(), java.lang.Object#getClass(), java.lang.Object#notify(), java.lang.Object#notifyAll()

Field Detail

### AND

    public static final java.lang.String AND

### BETWEEN

    public static final java.lang.String BETWEEN

### BIG_DECIMAL

    public static final org.hibernate.type.Type BIG_DECIMAL

### BIG_INTEGER

    public static final org.hibernate.type.Type BIG_INTEGER

### BINARY

    public static final org.hibernate.type.Type BINARY

### BLOB

    public static final org.hibernate.type.Type BLOB

### BOOLEAN

    public static final org.hibernate.type.Type BOOLEAN

### BYTE

    public static final org.hibernate.type.Type BYTE

### CALENDAR

    public static final org.hibernate.type.Type CALENDAR

### CALENDAR_DATE

    public static final org.hibernate.type.Type CALENDAR_DATE

### CHARACTER

    public static final org.hibernate.type.Type CHARACTER

### CHARACTERS_CLOB

    public static final org.hibernate.type.Type CHARACTERS_CLOB

### CHARACTER_ARRAY

    public static final org.hibernate.type.Type CHARACTER_ARRAY

### CHAR_ARRAY

    public static final org.hibernate.type.Type CHAR_ARRAY

### CLASS

    public static final org.hibernate.type.Type CLASS

### CLOB

    public static final org.hibernate.type.Type CLOB

### CURRENCY

    public static final org.hibernate.type.Type CURRENCY

### DATE

    public static final org.hibernate.type.Type DATE

### DOUBLE

    public static final org.hibernate.type.Type DOUBLE

### EQUALS

    public static final java.lang.String EQUALS

### EQUALS_PROPERTY

    public static final java.lang.String EQUALS_PROPERTY

### FLOAT

    public static final org.hibernate.type.Type FLOAT

### GREATER_THAN

    public static final java.lang.String GREATER_THAN

### GREATER_THAN_OR_EQUAL

    public static final java.lang.String GREATER_THAN_OR_EQUAL

### GREATER_THAN_OR_EQUAL_PROPERTY

    public static final java.lang.String GREATER_THAN_OR_EQUAL_PROPERTY

### GREATER_THAN_PROPERTY

    public static final java.lang.String GREATER_THAN_PROPERTY

### ID_EQUALS

    public static final java.lang.String ID_EQUALS

### ILIKE

    public static final java.lang.String ILIKE

### IMAGE

    public static final org.hibernate.type.Type IMAGE

### IN

    public static final java.lang.String IN

### INTEGER

    public static final org.hibernate.type.Type INTEGER

### IS_EMPTY

    public static final java.lang.String IS_EMPTY

### IS_NOT_EMPTY

    public static final java.lang.String IS_NOT_EMPTY

### IS_NOT_NULL

    public static final java.lang.String IS_NOT_NULL

### IS_NULL

    public static final java.lang.String IS_NULL

### LESS_THAN

    public static final java.lang.String LESS_THAN

### LESS_THAN_OR_EQUAL

    public static final java.lang.String LESS_THAN_OR_EQUAL

### LESS_THAN_OR_EQUAL_PROPERTY

    public static final java.lang.String LESS_THAN_OR_EQUAL_PROPERTY

### LESS_THAN_PROPERTY

    public static final java.lang.String LESS_THAN_PROPERTY

### LIKE

    public static final java.lang.String LIKE

### LOCALE

    public static final org.hibernate.type.Type LOCALE

### LONG

    public static final org.hibernate.type.Type LONG

### MATERIALIZED_BLOB

    public static final org.hibernate.type.Type MATERIALIZED_BLOB

### MATERIALIZED_CLOB

    public static final org.hibernate.type.Type MATERIALIZED_CLOB

### NOT

    public static final java.lang.String NOT

### NOT_EQUAL

    public static final java.lang.String NOT_EQUAL

### NOT_EQUAL_PROPERTY

    public static final java.lang.String NOT_EQUAL_PROPERTY

### NUMERIC_BOOLEAN

    public static final org.hibernate.type.Type NUMERIC_BOOLEAN

### OR

    public static final java.lang.String OR

### ORDER_ASCENDING

    public static final java.lang.String ORDER_ASCENDING

### ORDER_DESCENDING

    public static final java.lang.String ORDER_DESCENDING

### RLIKE

    public static final java.lang.String RLIKE

### SERIALIZABLE

    public static final org.hibernate.type.Type SERIALIZABLE

### SHORT

    public static final org.hibernate.type.Type SHORT

### SIZE_EQUALS

    public static final java.lang.String SIZE_EQUALS

### STRING

    public static final org.hibernate.type.Type STRING

### TEXT

    public static final org.hibernate.type.Type TEXT

### TIME

    public static final org.hibernate.type.Type TIME

### TIMESTAMP

    public static final org.hibernate.type.Type TIMESTAMP

### TIMEZONE

    public static final org.hibernate.type.Type TIMEZONE

### TRUE_FALSE

    public static final org.hibernate.type.Type TRUE_FALSE

### URL

    public static final org.hibernate.type.Type URL

### UUID_BINARY

    public static final org.hibernate.type.Type UUID_BINARY

### UUID_CHAR

    public static final org.hibernate.type.Type UUID_CHAR

### WRAPPER_BINARY

    public static final org.hibernate.type.Type WRAPPER_BINARY

### WRAPPER_CHARACTERS_CLOB

    public static final org.hibernate.type.Type WRAPPER_CHARACTERS_CLOB

### WRAPPER_MATERIALIZED_BLOB

    public static final org.hibernate.type.Type WRAPPER_MATERIALIZED_BLOB

### YES_NO

    public static final org.hibernate.type.Type YES_NO

Constructor Detail

### HibernateCriteriaBuilder

    * Set whether a unique result should be returned
    public HibernateCriteriaBuilder(java.lang.Class targetClass, org.hibernate.SessionFactory sessionFactory)

### HibernateCriteriaBuilder

    public HibernateCriteriaBuilder(java.lang.Class targetClass, org.hibernate.SessionFactory sessionFactory, boolean uniqueResult)

Method Detail

### addProjectionToList

    protected void addProjectionToList(org.hibernate.criterion.Projection propertyProjection, java.lang.String alias)

### avg

    public org.grails.datastore.mapping.query.api.ProjectionList avg(java.lang.String propertyName)

  Use a join query
  Parameters:
    `associationPath` - The path of the association

### avg

    public org.grails.datastore.mapping.query.api.ProjectionList avg(java.lang.String propertyName, java.lang.String alias)

### between

    public org.grails.datastore.mapping.query.api.Criteria between(java.lang.String propertyName, java.lang.Object lo, java.lang.Object hi)

### buildCriteria

    public org.hibernate.Criteria buildCriteria(groovy.lang.Closure criteriaClosure)

  Throws a runtime exception where necessary to ensure the session gets closed

### cache

    public void cache(boolean shouldCache)

### count

    public void count(java.lang.String propertyName)

  Adds a projection that allows the criteria to return the property count
  Parameters:
    `propertyName` - The name of the property
    `alias` - The alias to use

### count

    public void count(java.lang.String propertyName, java.lang.String alias)

### count

    public org.grails.datastore.mapping.query.api.ProjectionList count()

### countDistinct

    public org.grails.datastore.mapping.query.api.ProjectionList countDistinct(java.lang.String propertyName)

  Adds a projection that allows the criteria's result to be grouped by a property
  Parameters:
    `propertyName` - The name of the property

### countDistinct

    public org.grails.datastore.mapping.query.api.ProjectionList countDistinct(java.lang.String propertyName, java.lang.String alias)

### createAlias

    public org.hibernate.Criteria createAlias(java.lang.String associationPath, java.lang.String alias)

### createAlias

    public org.hibernate.Criteria createAlias(java.lang.String associationPath, java.lang.String alias, int joinType)

### distinct

    public org.grails.datastore.mapping.query.api.ProjectionList distinct(java.lang.String propertyName)

### distinct

    public org.grails.datastore.mapping.query.api.ProjectionList distinct(java.lang.String propertyName, java.lang.String alias)

  A distinct projection that takes a list
  Parameters:
    `propertyNames` - The list of distince property names
    `alias` - The alias to use

### distinct

    */
    public org.grails.datastore.mapping.query.api.ProjectionList distinct(java.util.Collection propertyNames)

### distinct

    public org.grails.datastore.mapping.query.api.ProjectionList avg(String propertyName, String alias) {
    public org.grails.datastore.mapping.query.api.ProjectionList distinct(java.util.Collection propertyNames, java.lang.String alias)

  Adds a projection that allows the criteria to return the property average value
  Parameters:
    `propertyName` - The name of the property
    `alias` - The alias to use

### distinct

    public org.grails.datastore.mapping.query.api.ProjectionList distinct()

### eq

    public org.grails.datastore.mapping.query.api.Criteria eq(java.lang.String propertyName, java.lang.Object propertyValue)

### eq

    eq = Property.forName(propertyName).eq((org.hibernate.criterion.DetachedCriteria) propertyValue);
    public org.grails.datastore.mapping.query.api.Criteria eq(java.util.Map params, java.lang.String propertyName, java.lang.Object propertyValue)

### eq

    /**
    public org.grails.datastore.mapping.query.api.Criteria eq(java.lang.String propertyName, java.lang.Object propertyValue, java.util.Map params)

### eqAll

    return ltAll(propertyName, new DetachedCriteria(targetClass).build(propertyValue));
    public org.grails.datastore.mapping.query.api.Criteria eqAll(java.lang.String propertyName, groovy.lang.Closure propertyValue)

  Creates a subquery criterion that ensures the given property is less than all the given returned values
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The property value
  Returns:
    A Criterion instance

### eqAll

    public org.grails.datastore.mapping.query.api.Criteria eqAll(java.lang.String propertyName, @SuppressWarnings("rawtypes") org.grails.datastore.mapping.query.api.QueryableCriteria propertyValue)

  Creates a subquery criterion that ensures the given property is less than all the given returned values
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The property value
  Returns:
    A Criterion instance

### eqProperty

    public org.grails.datastore.mapping.query.api.Criteria eqProperty(java.lang.String propertyName, java.lang.String otherPropertyName)

### fetchMode

    public void fetchMode(java.lang.String associationPath, org.hibernate.FetchMode fetchMode)

### ge

    public org.grails.datastore.mapping.query.api.Criteria ge(java.lang.String propertyName, java.lang.Object propertyValue)

  Creates a "less than" Criterion based on the specified property name and value
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The property value
  Returns:
    A Criterion instance

### geAll

    addToCriteria(Property.forName(propertyName).eqAll(getHibernateDetachedCriteria(propertyValue)));
    public org.grails.datastore.mapping.query.api.Criteria geAll(java.lang.String propertyName, groovy.lang.Closure propertyValue)

  Creates a subquery criterion that ensures the given property is equal to all the given returned values
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The property value
  Returns:
    A Criterion instance

### geAll

    public org.grails.datastore.mapping.query.api.Criteria geAll(java.lang.String propertyName, g.grails.datastore.mapping.que org.grails.datastore.mapping.query.api.QueryableCriteria propertyValue)

### geProperty

    public org.grails.datastore.mapping.query.api.Criteria geProperty(java.lang.String propertyName, java.lang.String otherPropertyName)

  Creates a Criterion that tests if the first property is less than the second property
  Parameters:
    `propertyName` - The first property name
    `otherPropertyName` - The second property name
  Returns:
    A Criterion instance

### getHibernateDetachedCriteria

    public static org.hibernate.criterion.DetachedCriteria getHibernateDetachedCriteria(org.grails.datastore.mapping.query.api.QueryableCriteria queryableCriteria)

### getInstance

    public org.hibernate.Criteria getInstance()

  A projection that selects a property name
  Parameters:
    `propertyName` - The name of the property
    `alias` - The alias to use

### getTargetClass

    public java.lang.Class getTargetClass()

### groupProperty

    public void groupProperty(java.lang.String propertyName)

  Adds a projection that allows the criteria to retrieve a maximum property value
  Parameters:
    `propertyName` - The name of the property

### groupProperty

    public void groupProperty(java.lang.String propertyName, java.lang.String alias)

### gt

    public org.grails.datastore.mapping.query.api.Criteria gt(java.lang.String propertyName, java.lang.Object propertyValue)

### gtAll

    return geAll(propertyName, new DetachedCriteria(targetClass).build(propertyValue));
    public org.grails.datastore.mapping.query.api.Criteria gtAll(java.lang.String propertyName, groovy.lang.Closure propertyValue)

  Creates a subquery criterion that ensures the given property is greater than all the given returned values
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The property value
  Returns:
    A Criterion instance

### gtAll

    public org.grails.datastore.mapping.query.api.Criteria gtAll(java.lang.String propertyName, g.grails.datastore.mapping.que org.grails.datastore.mapping.query.api.QueryableCriteria propertyValue)

### gtProperty

    public org.grails.datastore.mapping.query.api.Criteria gtProperty(java.lang.String propertyName, java.lang.String otherPropertyName)

  Creates a Criterion that tests if the first property is greater than or equal to the second property
  Parameters:
    `propertyName` - The first property name
    `otherPropertyName` - The second property name
  Returns:
    A Criterion instance

### gte

    public org.grails.datastore.mapping.query.api.Criteria gte(java.lang.String s, java.lang.Object o)

### id

    public org.grails.datastore.mapping.query.api.ProjectionList id()

### idEq

    public org.grails.datastore.mapping.query.api.Criteria idEq(java.lang.Object o)

### idEquals

    public org.grails.datastore.mapping.query.api.Criteria idEquals(java.lang.Object o)

### ilike

    public org.grails.datastore.mapping.query.api.Criteria ilike(java.lang.String propertyName, java.lang.Object propertyValue)

  Applys a "in" contrain on the specified property
  Parameters:
    `propertyName` - The property name
    `values` - A collection of values
  Returns:
    A Criterion instance

### in

    public org.grails.datastore.mapping.query.api.Criteria in(java.lang.String propertyName, java.util.Collection values)

  Delegates to in as in is a Groovy keyword

### in

    public org.grails.datastore.mapping.query.api.Criteria in(java.lang.String propertyName, java.lang.Object[] values)

### inList

    addToCriteria(Restrictions.in(propertyName, values));
    public org.grails.datastore.mapping.query.api.Criteria inList(java.lang.String propertyName, java.util.Collection values)

  Applys a "in" contrain on the specified property
  Parameters:
    `propertyName` - The property name
    `values` - A collection of values
  Returns:
    A Criterion instance

### inList

    public org.grails.datastore.mapping.query.api.Criteria inList(java.lang.String propertyName, java.lang.Object[] values)

### invokeMethod

    resultTransformer = CriteriaSpecification.DISTINCT_ROOT_ENTITY;
    }
    public java.lang.Object invokeMethod(java.lang.String name, java.lang.Object obj)

### isEmpty

    public org.grails.datastore.mapping.query.api.Criteria isEmpty(java.lang.String property)

### isNotEmpty

    public org.grails.datastore.mapping.query.api.Criteria isNotEmpty(java.lang.String property)

### isNotNull

    public org.grails.datastore.mapping.query.api.Criteria isNotNull(java.lang.String property)

### isNull

    public org.grails.datastore.mapping.query.api.Criteria isNull(java.lang.String property)

### join

    public void join(java.lang.String associationPath)

### le

    public org.grails.datastore.mapping.query.api.Criteria le(java.lang.String propertyName, java.lang.Object propertyValue)

### leAll

    @SuppressWarnings("rawtypes") QueryableCriteria propertyValue) {
    public org.grails.datastore.mapping.query.api.Criteria leAll(java.lang.String propertyName, groovy.lang.Closure propertyValue)

  Creates a subquery criterion that ensures the given property is greater than all the given returned values
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The property value
  Returns:
    A Criterion instance

### leAll

    public org.grails.datastore.mapping.query.api.Criteria leAll(java.lang.String propertyName, t = Restrictions.gt(propertyNa org.grails.datastore.mapping.query.api.QueryableCriteria propertyValue)

### leProperty

    public org.grails.datastore.mapping.query.api.Criteria leProperty(java.lang.String propertyName, java.lang.String otherPropertyName)

  Creates a subquery criterion that ensures the given property is equal to all the given returned values
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The property value
  Returns:
    A Criterion instance

### like

    public org.grails.datastore.mapping.query.api.Criteria like(java.lang.String propertyName, java.lang.Object propertyValue)

  Creates a Criterion with from the specified property name and "rlike" (a regular expression version of "like") expression
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The ilike value
  Returns:
    A Criterion instance

### lock

    public void lock(boolean shouldLock)

  Use a select query
  Parameters:
    `associationPath` - The path of the association

### lt

    public org.grails.datastore.mapping.query.api.Criteria lt(java.lang.String propertyName, java.lang.Object propertyValue)

  Creates a "less than or equal to" Criterion based on the specified property name and value
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The property value
  Returns:
    A Criterion instance

### ltAll

    return leAll(propertyName, new DetachedCriteria(targetClass).build(propertyValue));
    public org.grails.datastore.mapping.query.api.Criteria ltAll(java.lang.String propertyName, groovy.lang.Closure propertyValue)

  Creates a subquery criterion that ensures the given property is less than all the given returned values
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The property value
  Returns:
    A Criterion instance

### ltAll

    public org.grails.datastore.mapping.query.api.Criteria ltAll(java.lang.String propertyName,  org.grails.datastore.mapping.query.api.QueryableCriteria propertyValue)

### ltProperty

    public org.grails.datastore.mapping.query.api.Criteria ltProperty(java.lang.String propertyName, java.lang.String otherPropertyName)

  Creates a Criterion that tests if the first property is less than or equal to the second property
  Parameters:
    `propertyName` - The first property name
    `otherPropertyName` - The second property name
  Returns:
    A Criterion instance

### lte

    public org.grails.datastore.mapping.query.api.Criteria lte(java.lang.String s, java.lang.Object o)

### max

    public org.grails.datastore.mapping.query.api.ProjectionList max(java.lang.String propertyName)

  Adds a projection that allows the criteria to retrieve a minimum property value
  Parameters:
    `propertyName` - The name of the property

### max

    public org.grails.datastore.mapping.query.api.ProjectionList max(java.lang.String propertyName, java.lang.String alias)

### min

    public org.grails.datastore.mapping.query.api.ProjectionList min(java.lang.String propertyName)

  Adds a projection that allows the criteria to return the row count

### min

    public org.grails.datastore.mapping.query.api.ProjectionList min(java.lang.String propertyName, java.lang.String alias)

### ne

    public org.grails.datastore.mapping.query.api.Criteria ne(java.lang.String propertyName, java.lang.Object propertyValue)

  Creates a "between" Criterion based on the property name and specified lo and hi values
  Parameters:
    `propertyName` - The property name
    `lo` - The low value
    `hi` - The high value
  Returns:
    A Criterion instance

### neProperty

    public org.grails.datastore.mapping.query.api.Criteria neProperty(java.lang.String propertyName, java.lang.String otherPropertyName)

  Creates a Criterion that tests if the first property is greater than the second property
  Parameters:
    `propertyName` - The first property name
    `otherPropertyName` - The second property name
  Returns:
    A Criterion instance

### notEqual

    public org.grails.datastore.mapping.query.api.Criteria notEqual(java.lang.String propertyName, java.lang.Object propertyValue)

### order

    public org.grails.datastore.mapping.query.api.Criteria order(java.lang.String propertyName)

  Orders by the specified property name (defaults to ascending)
  Parameters:
    `o` - The property name to order by
  Returns:
    A Order instance

### order

    public org.grails.datastore.mapping.query.api.Criteria order(org.hibernate.criterion.Order o)

  Orders by the specified property name and direction
  Parameters:
    `propertyName` - The property name to order by
    `direction` - Either "asc" for ascending or "desc" for descending
  Returns:
    A Order instance

### order

    public org.grails.datastore.mapping.query.api.Criteria order(java.lang.String propertyName, java.lang.String direction)

### property

    public org.grails.datastore.mapping.query.api.ProjectionList property(java.lang.String propertyName)

### property

    public org.grails.datastore.mapping.query.api.ProjectionList property(java.lang.String propertyName, java.lang.String alias)

### resultTransformer

    public void resultTransformer(org.hibernate.transform.ResultTransformer transformer)

### rlike

    public org.grails.datastore.mapping.query.api.Criteria rlike(java.lang.String propertyName, java.lang.Object propertyValue)

  Creates a Criterion with from the specified property name and "ilike" (a case sensitive version of "like") expression
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The ilike value
  Returns:
    A Criterion instance

### rowCount

    public org.grails.datastore.mapping.query.api.ProjectionList rowCount()

### rowCount

    public org.grails.datastore.mapping.query.api.ProjectionList rowCount(java.lang.String alias)

### select

    public void select(java.lang.String associationPath)

  Whether to use the query cache
  Parameters:
    `shouldCache` - True if the query should be cached

### setGrailsApplication

    public void setGrailsApplication(GrailsApplication grailsApplication)

  A projection that selects a property name
  Parameters:
    `propertyName` - The name of the property

### setUniqueResult

    public void setUniqueResult(boolean uniqueResult)

### sizeEq

    public org.grails.datastore.mapping.query.api.Criteria sizeEq(java.lang.String propertyName, int size)

  Creates a Criterion that contrains a collection property to be greater than the given size
  Parameters:
    `propertyName` - The property name
    `size` - The size to constrain by
  Returns:
    A Criterion instance

### sizeGe

    public org.grails.datastore.mapping.query.api.Criteria sizeGe(java.lang.String propertyName, int size)

  Creates a Criterion that contrains a collection property to be less than or equal to the given size
  Parameters:
    `propertyName` - The property name
    `size` - The size to constrain by
  Returns:
    A Criterion instance

### sizeGt

    public org.grails.datastore.mapping.query.api.Criteria sizeGt(java.lang.String propertyName, int size)

  Creates a Criterion that contrains a collection property to be greater than or equal to the given size
  Parameters:
    `propertyName` - The property name
    `size` - The size to constrain by
  Returns:
    A Criterion instance

### sizeLe

    public org.grails.datastore.mapping.query.api.Criteria sizeLe(java.lang.String propertyName, int size)

  Creates a Criterion that contrains a collection property to be less than to the given size
  Parameters:
    `propertyName` - The property name
    `size` - The size to constrain by
  Returns:
    A Criterion instance

### sizeLt

    public org.grails.datastore.mapping.query.api.Criteria sizeLt(java.lang.String propertyName, int size)

  Creates a Criterion that contrains a collection property to be not equal to the given size
  Parameters:
    `propertyName` - The property name
    `size` - The size to constrain by
  Returns:
    A Criterion instance

### sizeNe

    public org.grails.datastore.mapping.query.api.Criteria sizeNe(java.lang.String propertyName, int size)

  Creates a "not equal" Criterion based on the specified property name and value
  Parameters:
    `propertyName` - The property name
    `propertyValue` - The property value
  Returns:
    The criterion object

### sqlGroupProjection

    protected void sqlGroupProjection(java.lang.String sql, java.lang.String groupBy, java.util.List columnAliases, java.util.List types)

### sqlProjection

    protected void sqlProjection(java.lang.String sql, java.lang.String columnAlias, org.hibernate.type.Type type)

  Adds a sql projection to the criteria
  Parameters:
    `sql` - SQL projecting
    `groupBy` - group by clause
    `columnAliases` - List of column aliases for the projected values
    `types` - List of types for the projected values

### sqlProjection

    protected void sqlProjection(java.lang.String sql, java.util.List columnAliases, java.util.List types)

  A projection that selects a distince property name
  Parameters:
    `propertyName` - The property name

### sqlRestriction

    public org.grails.datastore.mapping.query.api.Criteria sqlRestriction(java.lang.String sqlRestriction)

  Applies a sql restriction to the results to allow something like:

             def results = Person.withCriteria {
                 sqlRestriction "char_length(first_name) <= 4"
             }

  Parameters:
    `sqlRestriction` - the sql restriction
  Returns:
    a Criteria instance

### sqlRestriction

    public org.grails.datastore.mapping.query.api.Criteria sqlRestriction(java.lang.String sqlRestriction, java.util.List values)

### sum

    public org.grails.datastore.mapping.query.api.ProjectionList sum(java.lang.String propertyName)

  Sets the fetch mode of an associated path
  Parameters:
    `associationPath` - The name of the associated path
    `fetchMode` - The fetch mode to set

### sum

    public org.grails.datastore.mapping.query.api.ProjectionList sum(java.lang.String propertyName, java.lang.String alias)

  Sets the resultTransformer.
  Parameters:
    `transformer` - The result transformer to use.

Groovy Documentation