Uses of Interface
com.mysema.query.types.Expression

Packages that use Expression
com.mysema.query Contains basic Query elements 
com.mysema.query.alias Alias functionality 
com.mysema.query.apt APTFactory and related classes 
com.mysema.query.codegen Code generations models and serializers 
com.mysema.query.collections Implementations of Querydsl query interfaces for JavaBean collections 
com.mysema.query.dml DML interfaces 
com.mysema.query.jdo JDOQL support for Querydsl 
com.mysema.query.jdo.dml DML operations support for Querydsl JDOQL 
com.mysema.query.jdo.sql   
com.mysema.query.jpa Query implementations for HQL and JPAQL 
com.mysema.query.jpa.hibernate JPQL for Hibernate 
com.mysema.query.jpa.hibernate.sql   
com.mysema.query.jpa.impl HQL Support classes 
com.mysema.query.jpa.sql   
com.mysema.query.lucene   
com.mysema.query.mongodb   
com.mysema.query.sql SQL/JDBC support for Querydsl 
com.mysema.query.sql.dml DML operations support 
com.mysema.query.sql.mssql SQL Server support 
com.mysema.query.sql.mysql MySQL support 
com.mysema.query.sql.oracle Oracle support for Querydsl SQL 
com.mysema.query.support Various support classes 
com.mysema.query.types Contains Querydsl grammar types 
com.mysema.query.types.expr Operations represent typed operations with operator and arguments 
com.mysema.query.types.path Paths represent typed property paths, variables and list-map-array access 
com.mysema.query.types.query Subquery implementations 
com.mysema.query.types.template Custom types are comparable to operations but contain the serialization templates instead of operator patterns. 
 

Uses of Expression in com.mysema.query
 

Classes in com.mysema.query that implement Expression
 class BooleanBuilder
          BooleanBuilder is a cascading builder for Predicate expressions.
 

Methods in com.mysema.query that return Expression
 Expression<?> BooleanBuilder.getArg(int index)
           
 Expression<?> QueryFlag.getFlag()
           
 Expression<?> JoinFlag.getFlag()
           
 Expression<?> JoinExpression.getTarget()
           
 

Methods in com.mysema.query that return types with arguments of type Expression
 List<Expression<?>> BooleanBuilder.getArgs()
           
 List<? extends Expression<?>> QueryMetadata.getGroupBy()
          Get the group by expressions
 List<? extends Expression<?>> DefaultQueryMetadata.getGroupBy()
           
 List<? extends Expression<?>> QueryMetadata.getProjection()
          Get the projection
 List<? extends Expression<?>> DefaultQueryMetadata.getProjection()
           
 

Methods in com.mysema.query with parameters of type Expression
 void QueryMetadata.addGroupBy(Expression<?>... o)
          Add the given group by expressions
 void DefaultQueryMetadata.addGroupBy(Expression<?>... o)
           
 void QueryMetadata.addJoin(JoinType joinType, Expression<?> expr)
          Add the given query join
 void DefaultQueryMetadata.addJoin(JoinType joinType, Expression<?> expr)
           
 void QueryMetadata.addProjection(Expression<?>... o)
          Add the given projections
 void DefaultQueryMetadata.addProjection(Expression<?>... o)
           
<T> T
Tuple.get(Expression<T> expr)
          Get a tuple element by expression
 Q Query.groupBy(Expression<?>... o)
          Defines the grouping/aggregation expressions
 com.mysema.commons.lang.CloseableIterator<Object[]> Projectable.iterate(Expression<?>[] args)
          iterate over the results for the given projection
 com.mysema.commons.lang.CloseableIterator<Object[]> Projectable.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
          iterate over the results for the given projection
 com.mysema.commons.lang.CloseableIterator<Object[]> Projectable.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
          iterate over the results for the given projection
 com.mysema.commons.lang.CloseableIterator<Object[]> Projectable.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
          iterate over the results for the given projection
<RT> com.mysema.commons.lang.CloseableIterator<RT>
Projectable.iterate(Expression<RT> projection)
          iterate over the results for the given projection
 com.mysema.commons.lang.CloseableIterator<Object[]> Projectable.iterateDistinct(Expression<?>[] args)
          iterate over the distinct results for the given projection
 com.mysema.commons.lang.CloseableIterator<Object[]> Projectable.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
          iterate over the distinct results for the given projection
 com.mysema.commons.lang.CloseableIterator<Object[]> Projectable.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
          iterate over the distinct results for the given projection
 com.mysema.commons.lang.CloseableIterator<Object[]> Projectable.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
          iterate over the distinct results for the given projection
<RT> com.mysema.commons.lang.CloseableIterator<RT>
Projectable.iterateDistinct(Expression<RT> projection)
          iterate over the distinct results for the given projection
 List<Object[]> Projectable.list(Expression<?>[] args)
          list the results for the given projection An empty list is returned for no results.
 List<Object[]> Projectable.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
          list the results for the given projection An empty list is returned for no results.
 List<Object[]> Projectable.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
          list the results for the given projection An empty list is returned for no results.
 List<Object[]> Projectable.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
          list the results for the given projection An empty list is returned for no results.
<RT> List<RT>
Projectable.list(Expression<RT> projection)
          list the results for the given projection An empty list is returned for no results.
 List<Object[]> Projectable.listDistinct(Expression<?>[] args)
          list the distinct results for the given projection An empty list is returned for no results.
 List<Object[]> Projectable.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
          list the distinct results for the given projection An empty list is returned for no results.
 List<Object[]> Projectable.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
          list the distinct results for the given projection An empty list is returned for no results.
 List<Object[]> Projectable.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
          list the distinct results for the given projection An empty list is returned for no results.
<RT> List<RT>
Projectable.listDistinct(Expression<RT> projection)
          list the distinct results for the given projection An empty list is returned for no results.
<RT> SearchResults<RT>
Projectable.listDistinctResults(Expression<RT> projection)
          list the distinct results for the given projection
<RT> SearchResults<RT>
Projectable.listResults(Expression<RT> projection)
          list the results for the given projection
<K,V> Map<K,V>
Projectable.map(Expression<K> key, Expression<V> value)
          return the given projection as a Map instance using key and value for Map population An empty map is returned for no results.
<K,V> Map<K,V>
Projectable.map(Expression<K> key, Expression<V> value)
          return the given projection as a Map instance using key and value for Map population An empty map is returned for no results.
 Object[] Projectable.singleResult(Expression<?>[] args)
          return a single result for the given projection or null if no result is found
 Object[] Projectable.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
          return a single result for the given projection or null if no result is found
 Object[] Projectable.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
          return a single result for the given projection or null if no result is found
 Object[] Projectable.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
          return a single result for the given projection or null if no result is found
<RT> RT
Projectable.singleResult(Expression<RT> projection)
          return a single result for the given projection or null if no result is found
 Object[] Projectable.uniqueResult(Expression<?>[] args)
          return a unique result for the given projection or null if no result is found
 Object[] Projectable.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
          return a unique result for the given projection or null if no result is found
 Object[] Projectable.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
          return a unique result for the given projection or null if no result is found
 Object[] Projectable.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
          return a unique result for the given projection or null if no result is found
<RT> RT
Projectable.uniqueResult(Expression<RT> projection)
          return a unique result for the given projection or null if no result is found
 

Constructors in com.mysema.query with parameters of type Expression
JoinExpression(JoinType type, Expression<?> target)
           
JoinFlag(Expression<?> flag)
           
JoinFlag(Expression<?> flag, JoinFlag.Position position)
           
QueryFlag(QueryFlag.Position position, Expression<?> flag)
           
 

Uses of Expression in com.mysema.query.alias
 

Methods in com.mysema.query.alias with type parameters of type Expression
static
<D extends Expression<?>>
D
Alias.$()
          Convert the given alias to an expression
<A extends Expression<?>>
A
AliasFactory.getCurrent()
          Get the current thread bound expression without reseting it
<A extends Expression<?>>
A
AliasFactory.getCurrentAndReset()
          Get the current thread bound expression and reset it
 

Methods in com.mysema.query.alias that return Expression
static
<D> Expression<D>
Alias.getAny(D arg)
          Convert the given alias to an expression
 

Methods in com.mysema.query.alias with parameters of type Expression
static
<A> A
Alias.alias(Class<A> cl, Expression<? extends A> expr)
           
<A> A
AliasFactory.createAliasForExpr(Class<A> cl, Expression<? extends A> expr)
          Create an alias instance for the given class and Expression
<A> A
AliasFactory.createAliasForProperty(Class<A> cl, Object parent, Expression<?> path)
          Create an alias instance for the given class, parent and path
 void AliasFactory.setCurrent(Expression<?> expr)
          Set the thread bound expression to the given value
 

Uses of Expression in com.mysema.query.apt
 

Method parameters in com.mysema.query.apt with type arguments of type Expression
<T> void
DefaultConfiguration.addCustomType(Class<T> type, Class<? extends Expression<T>> queryType)
           
 

Uses of Expression in com.mysema.query.codegen
 

Method parameters in com.mysema.query.codegen with type arguments of type Expression
 void TypeMappings.register(com.mysema.codegen.model.TypeCategory category, Class<? extends Expression> expr, Class<? extends Path> path, Class<? extends TemplateExpression> template)
           
 

Uses of Expression in com.mysema.query.collections
 

Methods in com.mysema.query.collections with parameters of type Expression
<T> com.mysema.codegen.Evaluator<T>
DefaultEvaluatorFactory.create(QueryMetadata metadata, List<? extends Expression<?>> sources, Expression<T> projection)
          Create an Evaluator for the given query sources and projection
<T> com.mysema.codegen.Evaluator<List<T>>
DefaultEvaluatorFactory.createEvaluator(QueryMetadata metadata, Expression<? extends T> source, Predicate filter)
          Create an Evaluator for the given source and filter
 com.mysema.commons.lang.CloseableIterator<Object[]> AbstractColQuery.iterate(Expression<?>[] args)
           
<RT> com.mysema.commons.lang.CloseableIterator<RT>
AbstractColQuery.iterate(Expression<RT> projection)
           
 List<Object[]> AbstractColQuery.list(Expression<?>[] args)
           
<RT> List<RT>
AbstractColQuery.list(Expression<RT> projection)
           
<T> List<T>
QueryEngine.list(QueryMetadata metadata, Map<Expression<?>,Iterable<?>> iterables, Expression<T> projection)
          Evaluate the given query and return the projection as a list
<T> List<T>
DefaultQueryEngine.list(QueryMetadata metadata, Map<Expression<?>,Iterable<?>> iterables, Expression<T> projection)
           
<RT> SearchResults<RT>
AbstractColQuery.listResults(Expression<RT> projection)
           
<U> ColUpdateClause<T>
ColUpdateClause.set(Path<U> path, Expression<? extends U> expression)
           
 Object[] AbstractColQuery.uniqueResult(Expression<?>[] args)
           
<RT> RT
AbstractColQuery.uniqueResult(Expression<RT> expr)
           
 

Method parameters in com.mysema.query.collections with type arguments of type Expression
 long QueryEngine.count(QueryMetadata metadata, Map<Expression<?>,Iterable<?>> iterables)
          Evaluate the given query and return the count of matched rows
 long DefaultQueryEngine.count(QueryMetadata metadata, Map<Expression<?>,Iterable<?>> iterables)
           
<T> com.mysema.codegen.Evaluator<T>
DefaultEvaluatorFactory.create(QueryMetadata metadata, List<? extends Expression<?>> sources, Expression<T> projection)
          Create an Evaluator for the given query sources and projection
 boolean QueryEngine.exists(QueryMetadata metadata, Map<Expression<?>,Iterable<?>> iterables)
           
 boolean DefaultQueryEngine.exists(QueryMetadata metadata, Map<Expression<?>,Iterable<?>> iterables)
           
<T> List<T>
QueryEngine.list(QueryMetadata metadata, Map<Expression<?>,Iterable<?>> iterables, Expression<T> projection)
          Evaluate the given query and return the projection as a list
<T> List<T>
DefaultQueryEngine.list(QueryMetadata metadata, Map<Expression<?>,Iterable<?>> iterables, Expression<T> projection)
           
protected  void ColQuerySerializer.visitOperation(Class<?> type, Operator<?> operator, List<Expression<?>> args)
           
 

Uses of Expression in com.mysema.query.dml
 

Methods in com.mysema.query.dml with parameters of type Expression
<T> C
StoreClause.set(Path<T> path, Expression<? extends T> expression)
          Add an expression binding
 

Uses of Expression in com.mysema.query.jdo
 

Methods in com.mysema.query.jdo that return Expression
 Expression<?> JDOQLSerializer.getCandidatePath()
           
 

Methods in com.mysema.query.jdo with parameters of type Expression
<T> T
JDOTuple.get(Expression<T> expr)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> AbstractJDOQLQuery.iterate(Expression<?>[] args)
           
<RT> com.mysema.commons.lang.CloseableIterator<RT>
AbstractJDOQLQuery.iterate(Expression<RT> projection)
           
 List<Object[]> AbstractJDOQLQuery.list(Expression<?>[] args)
           
<RT> List<RT>
AbstractJDOQLQuery.list(Expression<RT> expr)
           
<RT> SearchResults<RT>
AbstractJDOQLQuery.listResults(Expression<RT> expr)
           
 Object[] AbstractJDOQLQuery.uniqueResult(Expression<?>[] args)
           
<RT> RT
AbstractJDOQLQuery.uniqueResult(Expression<RT> expr)
           
 

Method parameters in com.mysema.query.jdo with type arguments of type Expression
protected  void JDOQLSerializer.visitOperation(Class<?> type, Operator<?> operator, List<Expression<?>> args)
           
 

Constructors in com.mysema.query.jdo with parameters of type Expression
JDOQLSerializer(JDOQLTemplates templates, Expression<?> candidate)
           
 

Uses of Expression in com.mysema.query.jdo.dml
 

Methods in com.mysema.query.jdo.dml with parameters of type Expression
<T> JDOQLUpdateClause
JDOQLUpdateClause.set(Path<T> path, Expression<? extends T> expression)
           
 

Uses of Expression in com.mysema.query.jdo.sql
 

Methods in com.mysema.query.jdo.sql with parameters of type Expression
 T AbstractSQLQuery.addFlag(QueryFlag.Position position, Expression<?> flag)
           
 T AbstractSQLQuery.addFlag(QueryFlag.Position position, String prefix, Expression<?> expr)
           
 T AbstractSQLQuery.from(Expression<?>... args)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> JDOSQLQuery.iterate(Expression<?>[] args)
           
<RT> com.mysema.commons.lang.CloseableIterator<RT>
JDOSQLQuery.iterate(Expression<RT> projection)
           
 List<Object[]> JDOSQLQuery.list(Expression<?>[] args)
           
<RT> List<RT>
JDOSQLQuery.list(Expression<RT> expr)
           
<RT> SearchResults<RT>
JDOSQLQuery.listResults(Expression<RT> expr)
           
 Object[] JDOSQLQuery.uniqueResult(Expression<?>[] args)
           
<RT> RT
JDOSQLQuery.uniqueResult(Expression<RT> expr)
           
 

Uses of Expression in com.mysema.query.jpa
 

Methods in com.mysema.query.jpa that return Expression
static
<D> Expression<D>
JPQLGrammar.all(CollectionExpression<?,D> col)
           
static
<D> Expression<D>
JPQLGrammar.any(CollectionExpression<?,D> col)
           
static
<D> Expression<D>
JPQLGrammar.some(CollectionExpression<?,D> col)
           
 

Methods in com.mysema.query.jpa with parameters of type Expression
 T AbstractSQLQuery.addFlag(QueryFlag.Position position, Expression<?> flag)
           
 T AbstractSQLQuery.addFlag(QueryFlag.Position position, String prefix, Expression<?> expr)
           
 T AbstractSQLQuery.from(Expression<?>... args)
           
static
<D extends Number & Comparable<? super D>>
NumberExpression<?>
JPQLGrammar.sum(Expression<D> left)
          SUM returns Long when applied to state-fields of integral types (other than BigInteger); Double when applied to state-fields of floating point types; BigInteger when applied to state-fields of type BigInteger; and BigDecimal when applied to state-fields of type BigDecimal.
static
<D extends Number & Comparable<? super D>>
NumberExpression<Double>
JPQLGrammar.sumAsDouble(Expression<D> left)
           
static
<D extends Number & Comparable<? super D>>
NumberExpression<Long>
JPQLGrammar.sumAsLong(Expression<D> left)
           
 

Method parameters in com.mysema.query.jpa with type arguments of type Expression
protected  void JPQLSerializer.visitOperation(Class<?> type, Operator<?> operator, List<Expression<?>> args)
           
 

Uses of Expression in com.mysema.query.jpa.hibernate
 

Methods in com.mysema.query.jpa.hibernate with parameters of type Expression
 org.hibernate.Query AbstractHibernateQuery.createQuery(Expression<?> expr)
          Expose the original Hibernate query for the given projection
 org.hibernate.Query AbstractHibernateQuery.createQuery(Expression<?>[] args)
          Expose the original Hibernate query for the given projection
 org.hibernate.Query AbstractHibernateQuery.createQuery(Expression<?> expr1, Expression<?> expr2, Expression<?>... rest)
          Expose the original Hibernate query for the given projection
 org.hibernate.Query AbstractHibernateQuery.createQuery(Expression<?> expr1, Expression<?> expr2, Expression<?>... rest)
          Expose the original Hibernate query for the given projection
 org.hibernate.Query AbstractHibernateQuery.createQuery(Expression<?> expr1, Expression<?> expr2, Expression<?>... rest)
          Expose the original Hibernate query for the given projection
 com.mysema.commons.lang.CloseableIterator<Object[]> AbstractHibernateQuery.iterate(Expression<?>[] args)
          Return the query results as an Iterator.
<RT> com.mysema.commons.lang.CloseableIterator<RT>
AbstractHibernateQuery.iterate(Expression<RT> projection)
          Return the query results as an Iterator.
 List<Object[]> AbstractHibernateQuery.list(Expression<?>[] args)
           
<RT> List<RT>
AbstractHibernateQuery.list(Expression<RT> expr)
           
<RT> SearchResults<RT>
AbstractHibernateQuery.listResults(Expression<RT> expr)
           
 org.hibernate.ScrollableResults AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode, Expression<?> expr)
          Return the query results as ScrollableResults.
 org.hibernate.ScrollableResults AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode, Expression<?>[] args)
          Return the query results as ScrollableResults.
 org.hibernate.ScrollableResults AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode, Expression<?> expr1, Expression<?> expr2, Expression<?>... rest)
          Return the query results as ScrollableResults.
 org.hibernate.ScrollableResults AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode, Expression<?> expr1, Expression<?> expr2, Expression<?>... rest)
          Return the query results as ScrollableResults.
 org.hibernate.ScrollableResults AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode, Expression<?> expr1, Expression<?> expr2, Expression<?>... rest)
          Return the query results as ScrollableResults.
<T> HibernateUpdateClause
HibernateUpdateClause.set(Path<T> path, Expression<? extends T> expression)
           
 Object[] AbstractHibernateQuery.uniqueResult(Expression<?>[] args)
           
<RT> RT
AbstractHibernateQuery.uniqueResult(Expression<RT> expr)
           
 

Uses of Expression in com.mysema.query.jpa.hibernate.sql
 

Methods in com.mysema.query.jpa.hibernate.sql with parameters of type Expression
 org.hibernate.Query AbstractHibernateSQLQuery.createQuery(Expression<?>... args)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> AbstractHibernateSQLQuery.iterate(Expression<?>[] args)
           
<RT> com.mysema.commons.lang.CloseableIterator<RT>
AbstractHibernateSQLQuery.iterate(Expression<RT> projection)
           
 List<Object[]> AbstractHibernateSQLQuery.list(Expression<?>[] projection)
           
<RT> List<RT>
AbstractHibernateSQLQuery.list(Expression<RT> projection)
           
<RT> SearchResults<RT>
AbstractHibernateSQLQuery.listResults(Expression<RT> projection)
           
 Object[] AbstractHibernateSQLQuery.uniqueResult(Expression<?>[] args)
           
<RT> RT
AbstractHibernateSQLQuery.uniqueResult(Expression<RT> expr)
           
 

Uses of Expression in com.mysema.query.jpa.impl
 

Methods in com.mysema.query.jpa.impl with parameters of type Expression
 javax.persistence.Query AbstractJPAQuery.createQuery(Expression<?> expr)
          Expose the original JPA query for the given projection
 javax.persistence.Query AbstractJPAQuery.createQuery(Expression<?>[] args)
          Expose the original JPA query for the given projection
 javax.persistence.Query AbstractJPAQuery.createQuery(Expression<?> expr1, Expression<?> expr2, Expression<?>... rest)
          Expose the original JPA query for the given projection
 javax.persistence.Query AbstractJPAQuery.createQuery(Expression<?> expr1, Expression<?> expr2, Expression<?>... rest)
          Expose the original JPA query for the given projection
 javax.persistence.Query AbstractJPAQuery.createQuery(Expression<?> expr1, Expression<?> expr2, Expression<?>... rest)
          Expose the original JPA query for the given projection
 com.mysema.commons.lang.CloseableIterator<Object[]> AbstractJPAQuery.iterate(Expression<?>[] args)
           
<RT> com.mysema.commons.lang.CloseableIterator<RT>
AbstractJPAQuery.iterate(Expression<RT> projection)
           
 List<Object[]> AbstractJPAQuery.list(Expression<?>[] args)
           
<RT> List<RT>
AbstractJPAQuery.list(Expression<RT> expr)
           
<RT> SearchResults<RT>
AbstractJPAQuery.listResults(Expression<RT> expr)
           
<T> JPAUpdateClause
JPAUpdateClause.set(Path<T> path, Expression<? extends T> expression)
           
 Object[] AbstractJPAQuery.uniqueResult(Expression<?>[] args)
           
<RT> RT
AbstractJPAQuery.uniqueResult(Expression<RT> expr)
           
 

Uses of Expression in com.mysema.query.jpa.sql
 

Methods in com.mysema.query.jpa.sql with parameters of type Expression
 javax.persistence.Query AbstractJPASQLQuery.createQuery(Expression<?>... args)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> AbstractJPASQLQuery.iterate(Expression<?>[] args)
           
<RT> com.mysema.commons.lang.CloseableIterator<RT>
AbstractJPASQLQuery.iterate(Expression<RT> projection)
           
 List<Object[]> AbstractJPASQLQuery.list(Expression<?>[] args)
           
<RT> List<RT>
AbstractJPASQLQuery.list(Expression<RT> projection)
           
<RT> SearchResults<RT>
AbstractJPASQLQuery.listResults(Expression<RT> projection)
           
 Object[] AbstractJPASQLQuery.uniqueResult(Expression<?>[] args)
           
<RT> RT
AbstractJPASQLQuery.uniqueResult(Expression<RT> expr)
           
 

Uses of Expression in com.mysema.query.lucene
 

Classes in com.mysema.query.lucene that implement Expression
 class PhraseElement
          PhraseElement represents the embedded String as a phrase
 class QueryElement
          QueryElement wraps a Lucene Query
 class TermElement
          TermElement represents the embedded String as a term
 

Methods in com.mysema.query.lucene with parameters of type Expression
protected  String[] LuceneSerializer.convert(Path<?> leftHandSide, Expression<?> rightHandSide, QueryMetadata metadata)
          template method
protected  org.apache.lucene.search.Query LuceneSerializer.range(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
           
protected  org.apache.lucene.search.Query LuceneSerializer.range(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
           
protected  org.apache.lucene.search.Query LuceneSerializer.stringRange(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
           
protected  org.apache.lucene.search.Query LuceneSerializer.stringRange(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
           
 org.apache.lucene.search.Query LuceneSerializer.toQuery(Expression<?> expr, QueryMetadata metadata)
           
 

Uses of Expression in com.mysema.query.mongodb
 

Classes in com.mysema.query.mongodb that implement Expression
 class Point
          Point is an adapter type for Double[] arrays to use geo spatial querying features of Mongodb
 

Methods in com.mysema.query.mongodb with parameters of type Expression
 Object MongodbSerializer.handle(Expression<?> expression)
           
 

Uses of Expression in com.mysema.query.sql
 

Subinterfaces of Expression in com.mysema.query.sql
 interface RelationalPath<T>
          RelationalPath extends EntityPath to provide access to relational metadata
 

Classes in com.mysema.query.sql that implement Expression
 class QBeans
          Expression used to project a list of beans
 class RelationalPathBase<T>
          RelationalPathBase is a base class for RelationPath implements
 

Methods in com.mysema.query.sql that return Expression
 Expression<?> SQLSubQuery.union(SubQueryExpression<?>... sq)
           
 

Methods in com.mysema.query.sql that return types with arguments of type Expression
 List<Expression<?>> QBeans.getArgs()
           
 

Methods in com.mysema.query.sql with parameters of type Expression
 Q AbstractSQLSubQuery.addFlag(QueryFlag.Position position, Expression<?> flag)
          Add the given Expression as a query flag
 Q AbstractSQLQuery.addFlag(QueryFlag.Position position, Expression<?> flag)
          Add the given Expression as a query flag
 Q SQLCommonQuery.addFlag(QueryFlag.Position position, Expression<?> flag)
          Add the given Expression as a query flag
 Q AbstractSQLSubQuery.addFlag(QueryFlag.Position position, String prefix, Expression<?> expr)
          Add the given prefix and expression as a general query flag
 Q AbstractSQLQuery.addFlag(QueryFlag.Position position, String prefix, Expression<?> expr)
          Add the given prefix and expression as a general query flag
 Q SQLCommonQuery.addFlag(QueryFlag.Position position, String prefix, Expression<?> expr)
          Add the given prefix and expression as a general query flag
 Q AbstractSQLSubQuery.from(Expression<?>... args)
           
 Q AbstractSQLQuery.from(Expression<?>... args)
           
 Q SQLCommonQuery.from(Expression<?>... o)
          Defines the sources of the query
 SQLQueryImpl SQLQueryFactoryImpl.from(Expression<?> from)
           
 Q SQLQueryFactory.from(Expression<?> from)
           
 ResultSet AbstractSQLQuery.getResults(Expression<?>... exprs)
           
 ResultSet SQLQuery.getResults(Expression<?>... args)
          Get the results as an JDBC result set
 com.mysema.commons.lang.CloseableIterator<Object[]> AbstractSQLQuery.iterate(Expression<?>[] args)
           
<RT> com.mysema.commons.lang.CloseableIterator<RT>
AbstractSQLQuery.iterate(Expression<RT> expr)
           
 List<Object[]> AbstractSQLQuery.list(Expression<?>[] args)
           
<RT> List<RT>
AbstractSQLQuery.list(Expression<RT> expr)
           
<RT> SearchResults<RT>
AbstractSQLQuery.listResults(Expression<RT> expr)
           
 SQLSubQuery SQLQueryFactoryImpl.subQuery(Expression<?> from)
           
 SQ SQLQueryFactory.subQuery(Expression<?> from)
           
 Object[] AbstractSQLQuery.uniqueResult(Expression<?>[] expr)
           
<RT> RT
AbstractSQLQuery.uniqueResult(Expression<RT> expr)
           
 

Method parameters in com.mysema.query.sql with type arguments of type Expression
 void SQLSerializer.serializeForInsert(QueryMetadata metadata, RelationalPath<?> entity, List<Path<?>> columns, List<Expression<?>> values, SubQueryExpression<?> subQuery)
           
 void SQLSerializer.serializeForMerge(QueryMetadata metadata, RelationalPath<?> entity, List<Path<?>> keys, List<Path<?>> columns, List<Expression<?>> values, SubQueryExpression<?> subQuery)
           
 void SQLSerializer.serializeForUpdate(QueryMetadata metadata, RelationalPath<?> entity, List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates)
           
protected  void SQLSerializer.visitOperation(Class<?> type, Operator<?> operator, List<Expression<?>> args)
           
 

Uses of Expression in com.mysema.query.sql.dml
 

Methods in com.mysema.query.sql.dml that return types with arguments of type Expression
 List<Expression<?>> SQLMergeBatch.getValues()
           
 List<Expression<?>> SQLInsertBatch.getValues()
           
 

Methods in com.mysema.query.sql.dml with parameters of type Expression
<T> SQLMergeClause
SQLMergeClause.set(Path<T> path, Expression<? extends T> expression)
           
<T> SQLInsertClause
SQLInsertClause.set(Path<T> path, Expression<? extends T> expression)
           
<T> SQLUpdateClause
SQLUpdateClause.set(Path<T> path, Expression<? extends T> expression)
           
 

Constructor parameters in com.mysema.query.sql.dml with type arguments of type Expression
SQLInsertBatch(List<Path<?>> c, List<Expression<?>> v, SubQueryExpression<?> sq)
           
SQLMergeBatch(List<Path<?>> k, List<Path<?>> c, List<Expression<?>> v, SubQueryExpression<?> sq)
           
 

Uses of Expression in com.mysema.query.sql.mssql
 

Classes in com.mysema.query.sql.mssql that implement Expression
 class RowNumber
          RowNumber supports row_number constructs for MS SQL Server
 

Methods in com.mysema.query.sql.mssql with parameters of type Expression
 RowNumber RowNumber.as(Expression<Long> target)
           
 RowNumber RowNumber.partitionBy(Expression<?>... exprs)
           
 

Uses of Expression in com.mysema.query.sql.mysql
 

Methods in com.mysema.query.sql.mysql with parameters of type Expression
 MySQLQuery MySQLQueryFactory.from(Expression<?> from)
           
 SQLSubQuery MySQLQueryFactory.subQuery(Expression<?> from)
           
 

Uses of Expression in com.mysema.query.sql.oracle
 

Classes in com.mysema.query.sql.oracle that implement Expression
 class SumOver<A extends Number & Comparable<? super A>>
          SumOver is a fluent type for Oracle specific sum over / partition by / order by constructs
 

Methods in com.mysema.query.sql.oracle with parameters of type Expression
 OracleQuery OracleQueryFactory.from(Expression<?> from)
           
 SumOver<A> SumOver.order(Expression<?>... orderBy)
           
 OracleQuery OracleQuery.orderSiblingsBy(Expression<?> path)
           
 SumOver<A> SumOver.partition(Expression<?> partitionBy)
           
 SQLSubQuery OracleQueryFactory.subQuery(Expression<?> from)
           
static
<A extends Number & Comparable<? super A>>
SumOver<A>
OracleGrammar.sumOver(Expression<A> expr)
           
 

Constructors in com.mysema.query.sql.oracle with parameters of type Expression
SumOver(Expression<A> expr)
           
 

Uses of Expression in com.mysema.query.support
 

Methods in com.mysema.query.support that return Expression
static
<T> Expression<T>
Expressions.constant(T value)
           
 Expression<?>[] QueryMixin.convert(Expression<?>[] exprs)
           
<RT> Expression<RT>
QueryMixin.convert(Expression<RT> expr)
           
protected
<D> Expression<D>
QueryMixin.createAlias(CollectionExpression<?,D> target, Path<D> alias)
           
protected
<D> Expression<D>
QueryMixin.createAlias(Expression<D> path, Path<D> alias)
           
protected
<D> Expression<D>
QueryMixin.createAlias(MapExpression<?,D> target, Path<D> alias)
           
protected
<D> Expression<D>
QueryMixin.createAlias(SubQueryExpression<D> path, Path<D> alias)
           
 Expression<?> CollectionAnyVisitor.visit(Constant<?> expr, Context context)
           
 Expression<?> ListAccessVisitor.visit(Constant<?> expr, Context context)
           
 Expression<?> CollectionAnyVisitor.visit(FactoryExpression<?> expr, Context context)
           
 Expression<?> ListAccessVisitor.visit(FactoryExpression<?> expr, Context context)
           
 Expression<?> CollectionAnyVisitor.visit(Operation<?> expr, Context context)
           
 Expression<?> ListAccessVisitor.visit(Operation<?> expr, Context context)
           
 Expression<?> CollectionAnyVisitor.visit(ParamExpression<?> expr, Context context)
           
 Expression<?> ListAccessVisitor.visit(ParamExpression<?> expr, Context context)
           
 Expression<?> CollectionAnyVisitor.visit(Path<?> expr, Context context)
           
 Expression<?> ListAccessVisitor.visit(Path<?> expr, Context context)
           
 Expression<?> CollectionAnyVisitor.visit(SubQueryExpression<?> expr, Context context)
           
 Expression<?> ListAccessVisitor.visit(SubQueryExpression<?> expr, Context context)
           
 Expression<?> CollectionAnyVisitor.visit(TemplateExpression<?> expr, Context context)
           
 Expression<?> ListAccessVisitor.visit(TemplateExpression<?> expr, Context context)
           
 

Methods in com.mysema.query.support with parameters of type Expression
 void OrderedQueryMetadata.addJoin(JoinType joinType, Expression<?> expr)
           
 T QueryMixin.addToProjection(Expression<?>... o)
           
protected  void SerializerBase.appendAsString(Expression<?> expr)
           
static BooleanExpression Expressions.booleanTemplate(String template, Expression<?>... args)
           
static
<T extends Comparable<?>>
ComparableExpression<T>
Expressions.comparableTemplate(Class<T> cl, String template, Expression<?>... args)
           
 Expression<?>[] QueryMixin.convert(Expression<?>[] exprs)
           
<RT> Expression<RT>
QueryMixin.convert(Expression<RT> expr)
           
protected
<D> Expression<D>
QueryMixin.createAlias(Expression<D> path, Path<D> alias)
           
 T QueryMixin.from(Expression<?>... args)
           
 T QueryMixin.groupBy(Expression<?>... o)
           
 Q QueryBase.groupBy(Expression<?>... o)
           
 S SerializerBase.handle(Expression<?> expr)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableAdapter.iterate(Expression<?>[] args)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableAdapter.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableAdapter.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableAdapter.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableQuery.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableQuery.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableQuery.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
<RT> com.mysema.commons.lang.CloseableIterator<RT>
ProjectableAdapter.iterate(Expression<RT> projection)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableAdapter.iterateDistinct(Expression<?>[] args)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableQuery.iterateDistinct(Expression<?>[] args)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableAdapter.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableAdapter.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableAdapter.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableQuery.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableQuery.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 com.mysema.commons.lang.CloseableIterator<Object[]> ProjectableQuery.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
<RT> com.mysema.commons.lang.CloseableIterator<RT>
ProjectableAdapter.iterateDistinct(Expression<RT> projection)
           
<RT> com.mysema.commons.lang.CloseableIterator<RT>
ProjectableQuery.iterateDistinct(Expression<RT> projection)
           
 ListSubQuery<Object[]> DetachableQuery.list(Expression<?>[] args)
           
 List<Object[]> ProjectableAdapter.list(Expression<?>[] args)
           
 List<Object[]> ProjectableQuery.list(Expression<?>[] args)
           
 ListSubQuery<Object[]> DetachableAdapter.list(Expression<?>[] args)
           
 ListSubQuery<Object[]> DetachableMixin.list(Expression<?>[] args)
           
 ListSubQuery<Object[]> DetachableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 ListSubQuery<Object[]> DetachableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 ListSubQuery<Object[]> DetachableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 List<Object[]> ProjectableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 List<Object[]> ProjectableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 List<Object[]> ProjectableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 List<Object[]> ProjectableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 List<Object[]> ProjectableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 List<Object[]> ProjectableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 ListSubQuery<Object[]> DetachableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 ListSubQuery<Object[]> DetachableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 ListSubQuery<Object[]> DetachableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 ListSubQuery<Object[]> DetachableMixin.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 ListSubQuery<Object[]> DetachableMixin.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 ListSubQuery<Object[]> DetachableMixin.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
<RT> ListSubQuery<RT>
DetachableQuery.list(Expression<RT> projection)
           
<RT> List<RT>
ProjectableAdapter.list(Expression<RT> projection)
           
<RT> List<RT>
ProjectableQuery.list(Expression<RT> projection)
           
<RT> ListSubQuery<RT>
DetachableAdapter.list(Expression<RT> projection)
           
<RT> ListSubQuery<RT>
DetachableMixin.list(Expression<RT> projection)
           
 List<Object[]> ProjectableAdapter.listDistinct(Expression<?>[] args)
           
 List<Object[]> ProjectableQuery.listDistinct(Expression<?>[] args)
           
 List<Object[]> ProjectableAdapter.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 List<Object[]> ProjectableAdapter.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 List<Object[]> ProjectableAdapter.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 List<Object[]> ProjectableQuery.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 List<Object[]> ProjectableQuery.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 List<Object[]> ProjectableQuery.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
<RT> List<RT>
ProjectableAdapter.listDistinct(Expression<RT> projection)
           
<RT> List<RT>
ProjectableQuery.listDistinct(Expression<RT> projection)
           
<RT> SearchResults<RT>
ProjectableAdapter.listDistinctResults(Expression<RT> expr)
           
<RT> SearchResults<RT>
ProjectableQuery.listDistinctResults(Expression<RT> projection)
           
<RT> SearchResults<RT>
ProjectableAdapter.listResults(Expression<RT> expr)
           
<K,V> Map<K,V>
ProjectableAdapter.map(Expression<K> key, Expression<V> value)
           
<K,V> Map<K,V>
ProjectableAdapter.map(Expression<K> key, Expression<V> value)
           
<K,V> Map<K,V>
ProjectableQuery.map(Expression<K> key, Expression<V> value)
           
<K,V> Map<K,V>
ProjectableQuery.map(Expression<K> key, Expression<V> value)
           
static
<T extends Number & Comparable<?>>
NumberExpression<T>
Expressions.numberTemplate(Class<T> cl, String template, Expression<?>... args)
           
static
<T> SimpleExpression<T>
Expressions.operation(Class<T> type, Operator<? super T> operator, Expression<?>... args)
           
 Object[] ProjectableAdapter.singleResult(Expression<?>[] args)
           
 Object[] ProjectableQuery.singleResult(Expression<?>[] args)
           
 Object[] ProjectableAdapter.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 Object[] ProjectableAdapter.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 Object[] ProjectableAdapter.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 Object[] ProjectableQuery.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 Object[] ProjectableQuery.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 Object[] ProjectableQuery.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
<RT> RT
ProjectableAdapter.singleResult(Expression<RT> expr)
           
<RT> RT
ProjectableQuery.singleResult(Expression<RT> expr)
           
static StringExpression Expressions.stringTemplate(String template, Expression<?>... args)
           
static
<T> SimpleExpression<T>
Expressions.template(Class<T> cl, String template, Expression<?>... args)
           
 SimpleSubQuery<Object[]> DetachableQuery.unique(Expression<?>[] args)
           
 SimpleSubQuery<Object[]> DetachableAdapter.unique(Expression<?>[] args)
           
 SimpleSubQuery<Object[]> DetachableMixin.unique(Expression<?>[] args)
           
 SimpleSubQuery<Object[]> DetachableQuery.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 SimpleSubQuery<Object[]> DetachableQuery.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 SimpleSubQuery<Object[]> DetachableQuery.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 SimpleSubQuery<Object[]> DetachableAdapter.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 SimpleSubQuery<Object[]> DetachableAdapter.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 SimpleSubQuery<Object[]> DetachableAdapter.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 SimpleSubQuery<Object[]> DetachableMixin.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 SimpleSubQuery<Object[]> DetachableMixin.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 SimpleSubQuery<Object[]> DetachableMixin.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
<RT> SimpleSubQuery<RT>
DetachableQuery.unique(Expression<RT> projection)
           
<RT> SimpleSubQuery<RT>
DetachableAdapter.unique(Expression<RT> projection)
           
<RT> SimpleSubQuery<RT>
DetachableMixin.unique(Expression<RT> projection)
           
 Object[] ProjectableAdapter.uniqueResult(Expression<?>[] args)
           
 Object[] ProjectableAdapter.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 Object[] ProjectableAdapter.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 Object[] ProjectableAdapter.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 Object[] ProjectableQuery.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 Object[] ProjectableQuery.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
 Object[] ProjectableQuery.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
           
<RT> RT
ProjectableAdapter.uniqueResult(Expression<RT> expr)
           
 

Method parameters in com.mysema.query.support with type arguments of type Expression
protected  void SerializerBase.visitOperation(Class<?> type, Operator<?> operator, List<Expression<?>> args)
           
 

Constructors in com.mysema.query.support with parameters of type Expression
SimpleQueryAdapter(Q query, Expression<T> projection)
           
SimpleQueryAdapter(Query<?> query, Projectable projectable, Expression<T> projection)
           
 

Uses of Expression in com.mysema.query.types
 

Subinterfaces of Expression in com.mysema.query.types
 interface CollectionExpression<T extends Collection<E>,E>
          CollectionExpression represents java.util.Collection typed expressions
 interface Constant<T>
          Constant represents a general constant expression.
 interface EntityPath<T>
          EntityPath is the common interface for entity path expressions
 interface FactoryExpression<T>
          FactoryExpression represents factory expressions such as JavaBean or Constructor projections
 interface MapExpression<K,V>
          MapExpression represents java.util.Map typed expressions
 interface Operation<T>
          Operation represents an operation with operator and arguments
 interface ParametrizedExpression<T>
           
 interface ParamExpression<T>
          ParamExpression defines named and unnamed parameters in queries
 interface Path<T>
          Path represents a path expression
 interface Predicate
          Predicate is the common interface for Boolean typed expressions
 interface SubQueryExpression<T>
          SubQueryExpression represents a sub query.
 interface TemplateExpression<T>
          TemplateExpression provides base types for custom expressions with integrated serialization templates
 

Classes in com.mysema.query.types that implement Expression
 class ArrayConstructorExpression<T>
          ArrayConstructorExpression extends ExpressionBase to represent array initializers
 class ConstantImpl<T>
          ConstantImpl is the default implementation of the Constant interface
 class ConstructorExpression<T>
          ConstructorExpression represents a constructor invocation
 class ExpressionBase<T>
          ExpressionBase is the base class for Expression implementations
static class FactoryExpressionUtils.FactoryExpressionAdapter<T>
           
 class MappingProjection<T>
          Projection template that allows implementing arbitrary mapping of rows to result objects.
 class NullExpression<T>
          NullExpression defines a general null expression
 class OperationImpl<T>
          OperationImpl is the default implementation of the Operation interface
 class PathImpl<T>
          PathImpl defines a default implementation of the Path interface
 class PredicateOperation
          PredicateOperation provides a Boolean typed Operation implementation
 class PredicateTemplate
          PredicateTemplate provides a Boolean typed TemplateExpression implementation
 class QBean<T>
          QBean is a JavaBean populating projection type
 class QTuple
          QTuple represents a projection of type Tuple
 class SubQueryExpressionImpl<T>
          SubQueryExpressionImpl is the default implementation of the SubQueryExpression interface
 class TemplateExpressionImpl<T>
          Default implementation of the TemplateExpression interface
 

Fields in com.mysema.query.types with type parameters of type Expression
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toContainsViaLike
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toContainsViaLike
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toContainsViaLikeLower
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toContainsViaLikeLower
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toEndsWithViaLike
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toEndsWithViaLike
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toEndsWithViaLikeLower
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toEndsWithViaLikeLower
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toLowerCase
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toLowerCase
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toStartsWithViaLike
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toStartsWithViaLike
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toStartsWithViaLikeLower
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toStartsWithViaLikeLower
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toUpperCase
           
 org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> Converters.toUpperCase
           
 

Methods in com.mysema.query.types that return Expression
static
<D> Expression<D>
ExpressionUtils.as(Expression<D> source, Path<D> alias)
          Create an alias expression (source as alias) with the given source and alias
static
<D> Expression<D>
ExpressionUtils.as(Expression<D> source, String alias)
          Create an alias expression (source as alias) with the given source and alias
 Expression<?> Template.Element.convert(Expression<?> source)
           
static Expression<Long> ExpressionUtils.count(Expression<?> source)
           
static
<C> Expression<C>
TemplateExpressionImpl.create(Class<C> cl, String template, Expression<?>... args)
          Create a new TemplateExpression with the given template in String form and template arguments
static
<C> Expression<C>
TemplateExpressionImpl.create(Class<C> cl, Template template, Expression<?>... args)
          Create a new TemplateExpression with the given template and template arguments
 Expression<?> TemplateExpressionImpl.getArg(int index)
           
 Expression<?> OperationImpl.getArg(int i)
           
 Expression<?> TemplateExpression.getArg(int index)
          Get the argument with the given index
 Expression<?> Operation.getArg(int index)
          Get the argument with the given index
 Expression<T> PathMetadata.getExpression()
           
 Expression<T> OrderSpecifier.getTarget()
          Get the target expression of this OrderSpecifier
static Expression<String> ExpressionUtils.likeToRegex(Expression<String> expr)
          Convert the given like pattern to a regex pattern
static Expression<?> ExpressionUtils.merge(List<? extends Expression<?>> expressions)
           
static Expression<String> ExpressionUtils.regexToLike(Expression<String> expr)
           
 Expression<?> ExtractorVisitor.visit(Constant<?> expr, Void context)
           
 Expression<?> ExtractorVisitor.visit(FactoryExpression<?> expr, Void context)
           
 Expression<?> ExtractorVisitor.visit(Operation<?> expr, Void context)
           
 Expression<?> ExtractorVisitor.visit(ParamExpression<?> expr, Void context)
           
 Expression<?> ExtractorVisitor.visit(Path<?> expr, Void context)
           
 Expression<?> ExtractorVisitor.visit(SubQueryExpression<?> expr, Void context)
           
 Expression<?> ExtractorVisitor.visit(TemplateExpression<?> expr, Void context)
           
 

Methods in com.mysema.query.types that return types with arguments of type Expression
 List<Expression<?>> ArrayConstructorExpression.getArgs()
           
 List<Expression<?>> TemplateExpressionImpl.getArgs()
           
 List<Expression<?>> FactoryExpression.getArgs()
          Get the invocation arguments
 List<Expression<?>> MappingProjection.getArgs()
           
 List<Expression<?>> OperationImpl.getArgs()
           
 List<Expression<?>> ConstructorExpression.getArgs()
           
 List<Expression<?>> QBean.getArgs()
           
 List<Expression<?>> FactoryExpressionUtils.FactoryExpressionAdapter.getArgs()
           
 List<Expression<?>> TemplateExpression.getArgs()
          Get the arguments of the custom expression
 List<Expression<?>> QTuple.getArgs()
           
 List<Expression<?>> Operation.getArgs()
          Get the arguments of this operation
 

Methods in com.mysema.query.types with parameters of type Expression
static
<T> ArrayConstructorExpression<T>
Projections.array(Class<T[]> type, Expression<T>... exprs)
          Create a typed array projection for the given type and expressions
static
<D> Expression<D>
ExpressionUtils.as(Expression<D> source, Path<D> alias)
          Create an alias expression (source as alias) with the given source and alias
static
<D> Expression<D>
ExpressionUtils.as(Expression<D> source, String alias)
          Create an alias expression (source as alias) with the given source and alias
static
<T> QBean<T>
Projections.bean(Class<T> type, Expression<?>... exprs)
          Create a Bean populating projection for the given type and expressions
static
<T> QBean<T>
Projections.bean(Path<T> type, Expression<?>... exprs)
          Create a Bean populating projection for the given type and expressions
static
<T> ConstructorExpression<T>
Projections.constructor(Class<T> type, Expression<?>... exprs)
          Create a constructor invocation projection for the given type and expressions
 Expression<?> Template.Element.convert(Expression<?> source)
           
static Expression<Long> ExpressionUtils.count(Expression<?> source)
           
static
<RT> Operation<RT>
OperationImpl.create(Class<? extends RT> type, Operator<? super RT> operator, Expression<?>... args)
           
static
<C> Expression<C>
TemplateExpressionImpl.create(Class<C> cl, String template, Expression<?>... args)
          Create a new TemplateExpression with the given template in String form and template arguments
static
<C> Expression<C>
TemplateExpressionImpl.create(Class<C> cl, Template template, Expression<?>... args)
          Create a new TemplateExpression with the given template and template arguments
static
<D> ConstructorExpression<D>
ConstructorExpression.create(Class<D> type, Expression<?>... args)
           
static
<D> Predicate
ExpressionUtils.eq(Expression<D> left, Expression<? extends D> right)
          Create an left equals right expression
static
<D> Predicate
ExpressionUtils.eq(Expression<D> left, Expression<? extends D> right)
          Create an left equals right expression
static
<D> Predicate
ExpressionUtils.eqConst(Expression<D> left, D constant)
          Create an left equals constant expression
static
<T> QBean<T>
Projections.fields(Class<T> type, Expression<?>... exprs)
          Create a field access based Bean populating projection for the given type and expressions
static
<T> QBean<T>
Projections.fields(Path<T> type, Expression<?>... exprs)
          Create a field access based Bean populating projection for the given type and expressions
static PathMetadata<Integer> PathMetadataFactory.forArrayAccess(Path<?> parent, Expression<Integer> index)
           
static PathMetadata<Integer> PathMetadataFactory.forListAccess(Path<?> parent, Expression<Integer> index)
           
static
<KT> PathMetadata<KT>
PathMetadataFactory.forMapAccess(Path<?> parent, Expression<KT> key)
           
static
<D> Predicate
ExpressionUtils.in(Expression<D> left, Collection<? extends D> right)
          Create an left in right expression
static
<D> Predicate
ExpressionUtils.in(Expression<D> left, CollectionExpression<?,? extends D> right)
          Create an left in right expression
static Predicate ExpressionUtils.isNotNull(Expression<?> left)
          Create a left is not null expression
static Predicate ExpressionUtils.isNull(Expression<?> left)
          Create a left is null expression
static Expression<String> ExpressionUtils.likeToRegex(Expression<String> expr)
          Convert the given like pattern to a regex pattern
static
<D> Predicate
ExpressionUtils.ne(Expression<D> left, Expression<? super D> right)
          Create a left not equals right expression
static
<D> Predicate
ExpressionUtils.ne(Expression<D> left, Expression<? super D> right)
          Create a left not equals right expression
static
<D> Predicate
ExpressionUtils.neConst(Expression<D> left, D constant)
          Create a left not equals constant expression
static Expression<String> ExpressionUtils.regexToLike(Expression<String> expr)
           
 

Method parameters in com.mysema.query.types with type arguments of type Expression
static Expression<?> ExpressionUtils.merge(List<? extends Expression<?>> expressions)
           
 

Constructors in com.mysema.query.types with parameters of type Expression
ArrayConstructorExpression(Class<T[]> type, Expression<T>... args)
           
ArrayConstructorExpression(Expression<?>... args)
           
ConstructorExpression(Class<T> type, Class<?>[] paramTypes, Expression<?>... args)
           
MappingProjection(Class<? super T> type, Expression<?>... args)
           
MappingProjection(Class<? super T> type, Expression<?>[]... args)
           
OperationImpl(Class<? extends T> type, Operator<? super T> operator, Expression<?>... args)
           
OrderSpecifier(Order order, Expression<T> target)
           
PathMetadata(Path<?> parent, Expression<T> expression, PathType type)
           
PredicateOperation(Operator<Boolean> operator, Expression<?>... args)
           
PredicateTemplate(String template, Expression<?>... args)
           
PredicateTemplate(Template template, Expression<?>... args)
           
QBean(Class<T> type, boolean fieldAccess, Expression<?>... args)
           
QBean(Class<T> type, Expression<?>... args)
           
QBean(Path<T> type, boolean fieldAccess, Expression<?>... args)
           
QBean(Path<T> type, Expression<?>... args)
           
QTuple(Expression<?>... args)
           
QTuple(Expression<?>[]... args)
           
TemplateExpressionImpl(Class<? extends T> type, Template template, Expression<?>... args)
           
 

Constructor parameters in com.mysema.query.types with type arguments of type Expression
ConstructorExpression(Class<T> type, Class<?>[] paramTypes, List<Expression<?>> args)
           
OperationImpl(Class<? extends T> type, Operator<? super T> operator, List<Expression<?>> args)
           
PredicateOperation(Operator<Boolean> operator, List<Expression<?>> args)
           
PredicateTemplate(Template template, List<Expression<?>> args)
           
QBean(Class<T> type, boolean fieldAccess, Map<String,? extends Expression<?>> bindings)
           
QBean(Class<T> type, Map<String,? extends Expression<?>> bindings)
           
QBean(Path<T> type, boolean fieldAccess, Map<String,? extends Expression<?>> bindings)
           
QBean(Path<T> type, Map<String,? extends Expression<?>> bindings)
           
TemplateExpressionImpl(Class<? extends T> type, Template template, List<Expression<?>> args)
           
ValidatingVisitor(Collection<Expression<?>> known)
           
 

Uses of Expression in com.mysema.query.types.expr
 

Classes in com.mysema.query.types.expr with type parameters of type Expression
static class CaseBuilder.Cases<A,Q extends Expression<A>>
          Cascading typesafe Case builder
static class CaseBuilder.CaseWhen<A,Q extends Expression<A>>
          Intermediate When state
 class CaseForEqBuilder.Cases<T,Q extends Expression<T>>
           
 class CaseForEqBuilder.CaseWhen<T,Q extends Expression<T>>
           
 

Subinterfaces of Expression in com.mysema.query.types.expr
 interface ArrayExpression<T>
          ArrayExpression defines an interface for array typed expression
 interface ListExpression<E,Q extends SimpleExpression<? super E>>
          ListExpression represents java.util.List typed expressions
 

Classes in com.mysema.query.types.expr that implement Expression
 class BooleanExpression
          BooleanExpression represents boolean expressions
 class BooleanOperation
          BooleanOperation represents boolean operations
 class Coalesce<T extends Comparable>
          Coalesce defines a coalesce function invocation.
 class CollectionExpressionBase<T extends Collection<E>,E>
          CollectionExpressionBase is an abstract base class for CollectionExpression implementations
 class ComparableExpression<T extends Comparable>
          ComparableExpression extends ComparableExpressionBase to provide comparison methods.
 class ComparableExpressionBase<T extends Comparable>
          ComparableExpressionBase represents comparable expressions
 class ComparableOperation<T extends Comparable<?>>
          ComparableOperation represents Comparable operations
 class DateExpression<T extends Comparable>
          DateExpression represents Date expressions The date representation is compatible with the Gregorian calendar.
 class DateOperation<T extends Comparable<?>>
          DateOperation represents Date operations
 class DateTimeExpression<T extends Comparable>
          DateTimeExpression represents Date / Time expressions The date representation is compatible with the Gregorian calendar.
 class DateTimeOperation<T extends Comparable<?>>
          DateTimeOperation represents DateTime operations
 class EnumExpression<T extends Enum<T>>
          EnumExpression represents Enum typed expressions
 class EnumOperation<T extends Enum<T>>
          EnumOperation represents enum operations
 class MapExpressionBase<K,V,Q extends SimpleExpression<? super V>>
          MapExpressionBase is an abstract base class for MapExpression implementations
 class NumberExpression<T extends Number & Comparable<?>>
          NumberExpression represents a numeric expression
 class NumberOperation<T extends Number & Comparable<?>>
          NumberOperation represents numeric operations
 class Param<T>
          Param defines a parameter in a query with an optional name
 class SimpleExpression<T>
          SimpleExpression is the base class for Expression implementations.
 class SimpleOperation<T>
          SimpleOperation represents a simple operation expression
 class StringExpression
          StringExpression represents String expressions
 class StringOperation
          StringOperation represents a String typed operation
 class TemporalExpression<T extends Comparable>
          TemporalExpression is a supertype for Date/Time related types
 class TimeExpression<T extends Comparable>
          TimeExpression represents Time expressions
 class TimeOperation<T extends Comparable<?>>
          TimeOperation represents Time operations
 

Fields in com.mysema.query.types.expr declared as Expression
static Expression<Object[]> Wildcard.all
           
 

Methods in com.mysema.query.types.expr that return Expression
 Expression<?> DateOperation.getArg(int index)
           
 Expression<?> DateTimeOperation.getArg(int index)
           
 Expression<?> TimeOperation.getArg(int index)
           
 Expression<?> NumberOperation.getArg(int index)
           
 Expression<?> EnumOperation.getArg(int index)
           
 Expression<?> StringOperation.getArg(int index)
           
 Expression<?> BooleanOperation.getArg(int index)
           
 Expression<?> SimpleOperation.getArg(int index)
           
 Expression<?> ComparableOperation.getArg(int index)
           
 

Methods in com.mysema.query.types.expr that return types with arguments of type Expression
 List<Expression<?>> DateOperation.getArgs()
           
 List<Expression<?>> DateTimeOperation.getArgs()
           
 List<Expression<?>> TimeOperation.getArgs()
           
 List<Expression<?>> NumberOperation.getArgs()
           
 List<Expression<?>> EnumOperation.getArgs()
           
 List<Expression<?>> StringOperation.getArgs()
           
 List<Expression<?>> BooleanOperation.getArgs()
           
 List<Expression<?>> SimpleOperation.getArgs()
           
 List<Expression<?>> ComparableOperation.getArgs()
           
<A> CaseBuilder.Cases<A,Expression<A>>
CaseBuilder.Initial.then(A constant)
           
<A> CaseBuilder.Cases<A,Expression<A>>
CaseBuilder.Initial.then(Expression<A> expr)
           
<T> CaseForEqBuilder.Cases<T,Expression<T>>
CaseForEqBuilder.then(Expression<T> then)
           
<T> CaseForEqBuilder.Cases<T,Expression<T>>
CaseForEqBuilder.then(T then)
           
 

Methods in com.mysema.query.types.expr with parameters of type Expression
<N extends Number & Comparable<?>>
NumberExpression<T>
NumberExpression.add(Expression<N> right)
          Get the sum of this and right
 Coalesce<T> Coalesce.add(Expression<T> expr)
           
 BooleanExpression TemporalExpression.after(Expression<T> right)
          Get a this > right expression
 StringExpression StringExpression.append(Expression<String> str)
          Get the concatenation of this and str
 BooleanExpression TemporalExpression.before(Expression<T> right)
          Get a this < right expression
<A extends Number & Comparable<?>>
BooleanExpression
NumberExpression.between(Expression<A> from, Expression<A> to)
          Create a from < this < to expression
<A extends Number & Comparable<?>>
BooleanExpression
NumberExpression.between(Expression<A> from, Expression<A> to)
          Create a from < this < to expression
 BooleanExpression ComparableExpression.between(Expression<T> from, Expression<T> to)
          Get a first <= this <= second expression
 BooleanExpression ComparableExpression.between(Expression<T> from, Expression<T> to)
          Get a first <= this <= second expression
 SimpleExpression<Character> StringExpression.charAt(Expression<Integer> i)
          Get the character at the given index
 StringExpression StringExpression.concat(Expression<String> str)
          Get the concatenation of this and str
 BooleanExpression CollectionExpressionBase.contains(Expression<E> child)
           
 BooleanExpression MapExpressionBase.contains(Expression<K> key, Expression<V> value)
           
 BooleanExpression MapExpressionBase.contains(Expression<K> key, Expression<V> value)
           
 BooleanExpression StringExpression.contains(Expression<String> str)
          Returns true if the given String is contained
 BooleanExpression StringExpression.containsIgnoreCase(Expression<String> str)
           
 BooleanExpression MapExpressionBase.containsKey(Expression<K> key)
           
 BooleanExpression MapExpressionBase.containsValue(Expression<V> value)
           
static
<D extends Enum<D>>
EnumExpression<D>
EnumOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?>... args)
          Factory method
static
<D extends Number & Comparable<?>>
NumberExpression<D>
NumberOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?>... args)
          Factory method
static
<D> SimpleExpression<D>
SimpleOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
          Factory method
static
<D extends Comparable<?>>
DateExpression<D>
DateOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
          Factory method
static
<D extends Comparable<?>>
DateTimeExpression<D>
DateTimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
          Factory method
static
<D extends Comparable<?>>
TimeExpression<D>
TimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
          Factory method
static
<D extends Comparable<?>>
ComparableExpression<D>
ComparableOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
          Factory method
static BooleanExpression BooleanOperation.create(Operator<? super Boolean> op, Expression<?>... args)
           
static StringExpression StringOperation.create(Operator<? super String> op, Expression<?>... args)
           
protected abstract  Q CaseBuilder.Cases.createResult(Class<A> type, Expression<A> last)
           
protected abstract  Q CaseForEqBuilder.Cases.createResult(Class<T> type, Expression<T> last)
           
<N extends Number & Comparable<?>>
NumberExpression<Double>
NumberExpression.divide(Expression<N> right)
          Get the result of the operation this / right
 BooleanExpression StringExpression.endsWith(Expression<String> str)
          Returns true if this ends with str
 BooleanExpression StringExpression.endsWithIgnoreCase(Expression<String> str)
           
 BooleanExpression SimpleExpression.eq(Expression<? super T> right)
          Get a this == right expression
 BooleanExpression StringExpression.equalsIgnoreCase(Expression<String> str)
          Compares this EString to another EString, ignoring case considerations.
 Q ListExpression.get(Expression<Integer> index)
          Indexed access
 SimpleExpression<T> ArrayExpression.get(Expression<Integer> index)
          Get the element at the given index
abstract  Q MapExpressionBase.get(Expression<K> key)
           
<A extends Number & Comparable<?>>
BooleanExpression
NumberExpression.goe(Expression<A> right)
          Create a this >= right expression
 BooleanExpression ComparableExpression.goe(Expression<T> right)
          Get a this >= right expression
<A extends Number & Comparable<?>>
BooleanExpression
NumberExpression.gt(Expression<A> right)
          Create a this > right expression
 BooleanExpression ComparableExpression.gt(Expression<T> right)
          Get a this > right expression
 NumberExpression<Integer> StringExpression.indexOf(Expression<String> str)
          Get the index of the given substring in this String
 NumberExpression<Integer> StringExpression.indexOf(Expression<String> str, int i)
          Get the index of the given substring in this String, starting from the given index
<A extends Number & Comparable<?>>
BooleanExpression
NumberExpression.loe(Expression<A> right)
          Create a this <= right expression
 BooleanExpression ComparableExpression.loe(Expression<T> right)
          Get a this < right expression
<A extends Number & Comparable<?>>
BooleanExpression
NumberExpression.lt(Expression<A> right)
          Create a this < right expression
 BooleanExpression ComparableExpression.lt(Expression<T> right)
          Get a this < right expression
 BooleanExpression StringExpression.matches(Expression<String> regex)
          Return true if this String matches the given regular expression
static
<A extends Number & Comparable<?>>
NumberExpression<A>
NumberExpression.max(Expression<A> left, Expression<A> right)
          Return the greater of the given values
static
<A extends Number & Comparable<?>>
NumberExpression<A>
NumberExpression.max(Expression<A> left, Expression<A> right)
          Return the greater of the given values
static
<A extends Number & Comparable<?>>
NumberExpression<A>
NumberExpression.min(Expression<A> left, Expression<A> right)
          Return the smaller of the given values
static
<A extends Number & Comparable<?>>
NumberExpression<A>
NumberExpression.min(Expression<A> left, Expression<A> right)
          Return the smaller of the given values
<N extends Number & Comparable<?>>
NumberExpression<T>
NumberExpression.multiply(Expression<N> right)
          Get the result of the operation this * right
 BooleanExpression SimpleExpression.ne(Expression<? super T> right)
          Get a this <> right expression
<A extends Number & Comparable<?>>
BooleanExpression
NumberExpression.notBetween(Expression<A> from, Expression<A> to)
           
<A extends Number & Comparable<?>>
BooleanExpression
NumberExpression.notBetween(Expression<A> from, Expression<A> to)
           
 BooleanExpression ComparableExpression.notBetween(Expression<T> from, Expression<T> to)
          Get a this not between from and to expression
 BooleanExpression ComparableExpression.notBetween(Expression<T> from, Expression<T> to)
          Get a this not between from and to expression
 Q CaseBuilder.Cases.otherwise(Expression<A> expr)
           
 Q CaseForEqBuilder.Cases.otherwise(Expression<T> otherwise)
           
 StringExpression StringExpression.prepend(Expression<String> str)
          Prepend the given String and return the result
 BooleanExpression StringExpression.startsWith(Expression<String> str)
          Return true if this starts with str
 BooleanExpression StringExpression.startsWithIgnoreCase(Expression<String> str)
           
<N extends Number & Comparable<?>>
NumberExpression<T>
NumberExpression.subtract(Expression<N> right)
          Get the difference of this and right
 CaseBuilder.Cases<A,Q> CaseBuilder.CaseWhen.then(Expression<A> expr)
           
<A> CaseBuilder.Cases<A,Expression<A>>
CaseBuilder.Initial.then(Expression<A> expr)
           
 CaseForEqBuilder.Cases<T,Q> CaseForEqBuilder.CaseWhen.then(Expression<T> then)
           
<T> CaseForEqBuilder.Cases<T,Expression<T>>
CaseForEqBuilder.then(Expression<T> then)
           
<T extends Number & Comparable<?>>
CaseForEqBuilder.Cases<T,NumberExpression<T>>
CaseForEqBuilder.thenNumber(Expression<T> then)
           
 CaseForEqBuilder.CaseWhen<T,Q> CaseForEqBuilder.Cases.when(Expression<? extends D> when)
           
 CaseForEqBuilder<T> SimpleExpression.when(Expression<? extends T> other)
          Get a case expression builder
 

Constructors in com.mysema.query.types.expr with parameters of type Expression
CaseForEqBuilder.CaseWhen(CaseForEqBuilder.Cases<T,Q> cases, Expression<? extends D> when)
           
CaseForEqBuilder(Expression<D> base, Expression<? extends D> other)
           
CaseForEqBuilder(Expression<D> base, Expression<? extends D> other)
           
Coalesce(Class<? extends T> type, Expression... exprs)
           
Coalesce(Expression... exprs)
           
 

Uses of Expression in com.mysema.query.types.path
 

Classes in com.mysema.query.types.path that implement Expression
 class ArrayPath<E>
          ArrayPath represents an array typed path
 class BeanPath<T>
          BeanPath represents bean paths
 class BooleanPath
          BooleanPath represents boolean path expressions
 class CollectionPath<E,Q extends SimpleExpression<? super E>>
          CollectionPath represents collection paths
 class CollectionPathBase<C extends Collection<E>,E,Q extends SimpleExpression<? super E>>
          CollectionPath is a base class for collection typed paths
 class ComparableEntityPath<T extends Comparable>
           
 class ComparablePath<T extends Comparable>
          ComparablePath represents Comparable paths
 class DatePath<T extends Comparable>
          DatePath presents Date paths
 class DateTimePath<T extends Comparable>
          DateTimePath presents DateTime typed paths
 class EntityPathBase<T>
          EntityPathBase provides a base class for EntityPath implementations
 class EnumPath<T extends Enum<T>>
          EnumPath represents enum paths
 class ListPath<E,Q extends SimpleExpression<? super E>>
          ListPath represents list paths
 class MapPath<K,V,E extends SimpleExpression<? super V>>
          MapPath represents map paths
 class NumberPath<T extends Number & Comparable<?>>
          NumberPath represents numeric paths
 class PathBuilder<T>
          PathBuilder is an extension to EntityPathBase for dynamic path construction
 class SetPath<E,Q extends SimpleExpression<? super E>>
          SetPath represents set paths
 class SimplePath<T>
          SimplePath represents simple paths
 class StringPath
          StringPath represents String typed paths
 class TimePath<T extends Comparable>
          TimePath represented Time paths
 

Methods in com.mysema.query.types.path with parameters of type Expression
protected  PathMetadata<Integer> ListPath.forListAccess(Expression<Integer> index)
           
protected  PathMetadata<K> MapPath.forMapAccess(Expression<K> key)
           
 SimplePath<E> ArrayPath.get(Expression<Integer> index)
          Create a expression for indexed access
 Q ListPath.get(Expression<Integer> index)
           
 E MapPath.get(Expression<K> key)
           
 

Uses of Expression in com.mysema.query.types.query
 

Subinterfaces of Expression in com.mysema.query.types.query
 interface ExtendedSubQueryExpression<T>
          Extensions to the SubQueryExpression interface
 

Classes in com.mysema.query.types.query that implement Expression
 class BooleanSubQuery
          Boolean typed single result subquery
 class ComparableSubQuery<T extends Comparable<?>>
          Comparable typed single result subquery
 class DateSubQuery<T extends Comparable<?>>
          Date typed single result subquery
 class DateTimeSubQuery<T extends Comparable<?>>
          DateTime typed single result subquery
 class ListSubQuery<T>
          List result subquery
 class NumberSubQuery<T extends Number & Comparable<?>>
          Number typed single result subquery
 class SimpleSubQuery<T>
          Object typed single result subquery
 class StringSubQuery
          String typed single result subquery
 class TimeSubQuery<T extends Comparable<?>>
          Time typed single result subquery
 

Methods in com.mysema.query.types.query with parameters of type Expression
 SimpleExpression<?> ListSubQuery.as(Expression<?> alias)
           
 ListSubQuery<Object[]> Detachable.list(Expression<?>[] args)
          Create a projection expression for the given projection
 ListSubQuery<Object[]> Detachable.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
          Create a projection expression for the given projection
 ListSubQuery<Object[]> Detachable.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
          Create a projection expression for the given projection
 ListSubQuery<Object[]> Detachable.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
          Create a projection expression for the given projection
<RT> ListSubQuery<RT>
Detachable.list(Expression<RT> projection)
          Create a projection expression for the given projection
 SimpleSubQuery<Object[]> Detachable.unique(Expression<?>[] args)
          Create a projection expression for the given projection
 SimpleSubQuery<Object[]> Detachable.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
          Create a projection expression for the given projection
 SimpleSubQuery<Object[]> Detachable.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
          Create a projection expression for the given projection
 SimpleSubQuery<Object[]> Detachable.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
          Create a projection expression for the given projection
<RT> SimpleSubQuery<RT>
Detachable.unique(Expression<RT> projection)
          Create a subquery expression for the given projection
 

Uses of Expression in com.mysema.query.types.template
 

Classes in com.mysema.query.types.template that implement Expression
 class BooleanTemplate
          BooleanTemplate is a custom boolean expression
 class ComparableTemplate<T extends Comparable<?>>
          ComparableTemplate defines custom comparable expressions
 class DateTemplate<T extends Comparable<?>>
          DateTemplate defines custom date expressions
 class DateTimeTemplate<T extends Comparable<?>>
          DateTimeTemplate defines custom dateTime expressions
 class EnumTemplate<T extends Enum<T>>
          EnumTemplate defines custom enum expressions
 class NumberTemplate<T extends Number & Comparable<?>>
          NumberTemplate defines custom numeric expressions
 class SimpleTemplate<T>
          SimpleTemplate defines custom simple expressions
 class StringTemplate
          StringTemplate defines custom String expressions
 class TimeTemplate<T extends Comparable<?>>
          TimeTemplate defines custom time expressions
 

Methods in com.mysema.query.types.template that return Expression
 Expression<?> TimeTemplate.getArg(int index)
           
 Expression<?> BooleanTemplate.getArg(int index)
           
 Expression<?> EnumTemplate.getArg(int index)
           
 Expression<?> DateTimeTemplate.getArg(int index)
           
 Expression<?> ComparableTemplate.getArg(int index)
           
 Expression<?> StringTemplate.getArg(int index)
           
 Expression<?> NumberTemplate.getArg(int index)
           
 Expression<?> DateTemplate.getArg(int index)
           
 Expression<?> SimpleTemplate.getArg(int index)
           
 

Methods in com.mysema.query.types.template that return types with arguments of type Expression
 List<Expression<?>> TimeTemplate.getArgs()
           
 List<Expression<?>> BooleanTemplate.getArgs()
           
 List<Expression<?>> EnumTemplate.getArgs()
           
 List<Expression<?>> DateTimeTemplate.getArgs()
           
 List<Expression<?>> ComparableTemplate.getArgs()
           
 List<Expression<?>> StringTemplate.getArgs()
           
 List<Expression<?>> NumberTemplate.getArgs()
           
 List<Expression<?>> DateTemplate.getArgs()
           
 List<Expression<?>> SimpleTemplate.getArgs()
           
 

Methods in com.mysema.query.types.template with parameters of type Expression
static
<T> SimpleExpression<T>
SimpleTemplate.create(Class<? extends T> type, String template, Expression<?>... args)
           
static
<T> SimpleExpression<T>
SimpleTemplate.create(Class<? extends T> type, Template template, Expression<?>... args)
           
static
<T extends Comparable<?>>
TimeTemplate<T>
TimeTemplate.create(Class<T> type, String template, Expression<?>... args)
           
static
<T extends Comparable<?>>
DateTimeExpression<T>
DateTimeTemplate.create(Class<T> type, String template, Expression<?>... args)
           
static
<T extends Comparable<?>>
ComparableExpression<T>
ComparableTemplate.create(Class<T> type, String template, Expression<?>... args)
           
static
<T extends Comparable<?>>
DateExpression<T>
DateTemplate.create(Class<T> type, String template, Expression<?>... args)
           
static
<T extends Enum<T>>
EnumExpression<T>
EnumTemplate.create(Class<T> type, String template, Expression<?>... args)
           
static
<T extends Number & Comparable<?>>
NumberExpression<T>
NumberTemplate.create(Class<T> type, String template, Expression<?>... args)
           
static
<T extends Comparable<?>>
TimeTemplate<T>
TimeTemplate.create(Class<T> type, Template template, Expression<?>... args)
           
static
<T extends Comparable<?>>
DateTimeExpression<T>
DateTimeTemplate.create(Class<T> type, Template template, Expression<?>... args)
           
static
<T extends Comparable<?>>
ComparableExpression<T>
ComparableTemplate.create(Class<T> type, Template template, Expression<?>... args)
           
static
<T extends Comparable<?>>
DateExpression<T>
DateTemplate.create(Class<T> type, Template template, Expression<?>... args)
           
static
<T extends Enum<T>>
EnumExpression<T>
EnumTemplate.create(Class<T> type, Template template, Expression<?>... args)
           
static
<T extends Number & Comparable<?>>
NumberExpression<T>
NumberTemplate.create(Class<T> type, Template template, Expression<?>... args)
           
static BooleanExpression BooleanTemplate.create(String template, Expression<?>... args)
           
static StringExpression StringTemplate.create(String template, Expression<?>... args)
           
static BooleanExpression BooleanTemplate.create(Template template, Expression<?>... args)
           
static StringExpression StringTemplate.create(Template template, Expression<?>... args)
           
 

Constructor parameters in com.mysema.query.types.template with type arguments of type Expression
BooleanTemplate(Template template, List<Expression<?>> args)
           
ComparableTemplate(Class<T> type, Template template, List<Expression<?>> args)
           
DateTemplate(Class<T> type, Template template, List<Expression<?>> args)
           
DateTimeTemplate(Class<T> type, Template template, List<Expression<?>> args)
           
EnumTemplate(Class<T> type, Template template, List<Expression<?>> args)
           
NumberTemplate(Class<T> type, Template template, List<Expression<?>> args)
           
SimpleTemplate(Class<? extends T> type, Template template, List<Expression<?>> args)
           
StringTemplate(Template template, List<Expression<?>> args)
           
TimeTemplate(Class<T> type, Template template, List<Expression<?>> args)
           
 



Copyright © 2007-2011 Mysema Ltd. All Rights Reserved.