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

Packages that use Expression

Package	Description
com.mysema.query	Contains basic Query elements
com.mysema.query.alias	Alias functionality
com.mysema.query.apt	APT 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.group
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	JPQL for JPA
com.mysema.query.jpa.sql
com.mysema.query.lucene
com.mysema.query.mongodb
com.mysema.query.spatial
com.mysema.query.spatial.path
com.mysema.query.sql	SQL/JDBC support for Querydsl
com.mysema.query.sql.dml	DML operations support
com.mysema.query.sql.mysql	MySQL support
com.mysema.query.sql.oracle	Oracle support for Querydsl SQL
com.mysema.query.sql.spatial
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

Modifier and Type	Class and Description
class	BooleanBuilder BooleanBuilder is a cascading builder for Predicate expressions.

Methods in com.mysema.query that return Expression

Modifier and Type	Method and Description
Expression<?>	JoinFlag.getFlag()
Expression<?>	QueryFlag.getFlag()
Expression<?>	JoinExpression.getTarget()

Methods in com.mysema.query that return types with arguments of type Expression

Modifier and Type	Method and Description
List<Expression<?>>	EmptyMetadata.getGroupBy()
List<Expression<?>>	QueryMetadata.getGroupBy() Get the group by expressions
List<Expression<?>>	DefaultQueryMetadata.getGroupBy()
List<Expression<?>>	EmptyMetadata.getProjection()
List<Expression<?>>	QueryMetadata.getProjection() Get the projection
List<Expression<?>>	DefaultQueryMetadata.getProjection()

Methods in com.mysema.query with parameters of type Expression

Modifier and Type	Method and Description
void	EmptyMetadata.addGroupBy(Expression<?> o)
void	QueryMetadata.addGroupBy(Expression<?> o) Add the given group by expressions
void	DefaultQueryMetadata.addGroupBy(Expression<?> o)
void	EmptyMetadata.addJoin(JoinType joinType, Expression<?> expr)
void	QueryMetadata.addJoin(JoinType joinType, Expression<?> expr) Add the given query join
void	DefaultQueryMetadata.addJoin(JoinType joinType, Expression<?> expr)
void	EmptyMetadata.addProjection(Expression<?> o)
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) Add grouping/aggregation expressions
com.mysema.commons.lang.CloseableIterator<Tuple>	Projectable.iterate(Expression<?>... args) 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
ListSubQuery<Tuple>	Detachable.list(Expression<?>... args) Create a projection expression for the given projection
List<Tuple>	Projectable.list(Expression<?>... args) list the results for the given projection An empty list is returned for no results.
<RT> ListSubQuery<RT>	Detachable.list(Expression<RT> projection) Create a projection expression for the given projection
<RT> List<RT>	Projectable.list(Expression<RT> projection) list the results for the given projection An empty list is returned for no results.
SearchResults<Tuple>	Projectable.listResults(Expression<?>... args) list the 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.
Tuple	Projectable.singleResult(Expression<?>... args) 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
SimpleSubQuery<Tuple>	Detachable.unique(Expression<?>... args) Create a projection expression for the given projection
<RT> SimpleSubQuery<RT>	Detachable.unique(Expression<RT> projection) Create a subquery expression for the given projection
Tuple	Projectable.uniqueResult(Expression<?>... args) 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

Constructor and Description
JoinExpression(JoinType type, Expression<?> target) Create a new JoinExpression instance
JoinExpression(JoinType type, Expression<?> target, Predicate condition, Set<JoinFlag> flags) Create a new JoinExpression instance
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

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
static <A> A	Alias.alias(Class<A> cl, Expression<? extends A> expr) Create a new alias proxy of the given type for the given expression
<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
protected <A> A	AliasFactory.createProxy(Class<A> cl, Expression<?> path) Create a proxy instance for the given class and path
void	AliasFactory.setCurrent(Expression<?> expr) Set the thread bound expression to the given value

Constructors in com.mysema.query.alias with parameters of type Expression

Constructor and Description
PropertyAccessInvocationHandler(Expression<?> host, AliasFactory aliasFactory, PathFactory pathFactory, TypeSystem typeSystem)

Uses of Expression in com.mysema.query.apt

Method parameters in com.mysema.query.apt with type arguments of type Expression

Modifier and Type	Method and Description
<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

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
static Number	CollQueryFunctions.aggregate(Collection<Number> source, Expression<?> expr, Operator<?> aggregator)
<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<Tuple>	AbstractCollQuery.iterate(Expression<?>... args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	AbstractCollQuery.iterate(Expression<RT> projection)
List<Tuple>	AbstractCollQuery.list(Expression<?>... args)
<RT> List<RT>	AbstractCollQuery.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)
SearchResults<Tuple>	AbstractCollQuery.listResults(Expression<?>... args)
<RT> SearchResults<RT>	AbstractCollQuery.listResults(Expression<RT> projection)
<U> CollUpdateClause<T>	CollUpdateClause.set(Path<U> path, Expression<? extends U> expression)
Tuple	AbstractCollQuery.uniqueResult(Expression<?>... args)
<RT> RT	AbstractCollQuery.uniqueResult(Expression<RT> expr)
static <F,T> com.google.common.base.Function<F,T>	GuavaHelpers.wrap(Expression<T> projection) Wrap a Querydsl expression into a Guava function

Method parameters in com.mysema.query.collections with type arguments of type Expression

Modifier and Type	Method and Description
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	CollQuerySerializer.visitOperation(Class<?> type, Operator<?> operator, List<? extends Expression<?>> args)

Uses of Expression in com.mysema.query.dml

Methods in com.mysema.query.dml with parameters of type Expression

Modifier and Type	Method and Description
<T> C	StoreClause.set(Path<T> path, Expression<? extends T> expression) Add an expression binding

Uses of Expression in com.mysema.query.group

Subinterfaces of Expression in com.mysema.query.group

Modifier and Type	Interface and Description
interface	GroupExpression<T,R> Defines the way results of a given expression are grouped.

Classes in com.mysema.query.group that implement Expression

Modifier and Type	Class and Description
class	AbstractGroupExpression<T,R> A base class for GroupExpressions
class	GAvg<T extends Number & Comparable<T>>
class	GSum<T extends Number & Comparable<T>>
class	MixinGroupExpression<E,F,R>
class	QPair<K,V> A pair of (Map) key and value

Methods in com.mysema.query.group that return Expression

Modifier and Type	Method and Description
Expression<T>	AbstractGroupExpression.getExpression()
Expression<T>	GroupExpression.getExpression()

Methods in com.mysema.query.group with parameters of type Expression

Modifier and Type	Method and Description
ResultTransformer<Map<K,Group>>	GroupByBuilder.as(Expression<?>... expressions) Get the results as a map
<V> ResultTransformer<Map<K,V>>	GroupByBuilder.as(Expression<V> expression) Get the results as a map
static <E extends Number & Comparable<E>> AbstractGroupExpression<E,E>	GroupBy.avg(Expression<E> expression) Create a new aggregating avg expression
static <K,V> QPair<K,V>	QPair.create(Expression<K> key, Expression<V> value)
static <K,V> QPair<K,V>	QPair.create(Expression<K> key, Expression<V> value)
boolean	QPair.equals(Expression<?> keyExpr, Class<?> valueType)
boolean	QPair.equals(Expression<?> keyExpr, Expression<?> valueExpr)
boolean	QPair.equals(Expression<?> keyExpr, Expression<?> valueExpr)
<T> List<T>	Group.getList(Expression<T> expr) Returns a List of values in this group.
<K,V> Map<K,V>	Group.getMap(Expression<K> key, Expression<V> value) Returns a Map of values in this group
<K,V> Map<K,V>	Group.getMap(Expression<K> key, Expression<V> value) Returns a Map of values in this group
<T> T	Group.getOne(Expression<T> expr) Returns the value of the given single valued expression.
<T> Set<T>	Group.getSet(Expression<T> expr) Returns a Set of values in this group.
static GroupByBuilder<List<?>>	GroupBy.groupBy(Expression<?>... keys) Create a new GroupByBuilder for the given key expressions
static <K> GroupByBuilder<K>	GroupBy.groupBy(Expression<K> key) Create a new GroupByBuilder for the given key expression
ResultTransformer<com.mysema.commons.lang.CloseableIterator<Group>>	GroupByBuilder.iterate(Expression<?>... expressions) Get the results as a closeable iterator
<V> ResultTransformer<com.mysema.commons.lang.CloseableIterator<V>>	GroupByBuilder.iterate(Expression<V> expression) Get the results as a closeable iterator
ResultTransformer<List<Group>>	GroupByBuilder.list(Expression<?>... expressions) Get the results as a list
static <E> AbstractGroupExpression<E,List<E>>	GroupBy.list(Expression<E> expression) Create a new aggregating list expression
<V> ResultTransformer<List<V>>	GroupByBuilder.list(Expression<V> expression) Get the results as a list
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<K,V>>	GroupBy.map(Expression<K> key, Expression<V> value) Create a new aggregating map expression
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<K,V>>	GroupBy.map(Expression<K> key, Expression<V> value) Create a new aggregating map expression
static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<K,U>>	GroupBy.map(Expression<K> key, GroupExpression<V,U> value)
static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<T,V>>	GroupBy.map(GroupExpression<K,T> key, Expression<V> value)
static <E extends Comparable<E>> AbstractGroupExpression<E,E>	GroupBy.max(Expression<E> expression) Create a new aggregating max expression
static <E extends Comparable<E>> AbstractGroupExpression<E,E>	GroupBy.min(Expression<E> expression) Create a new aggregating min expression
static <E> AbstractGroupExpression<E,Set<E>>	GroupBy.set(Expression<E> expression) Create a new aggregating set expression
static <E extends Number & Comparable<E>> AbstractGroupExpression<E,E>	GroupBy.sum(Expression<E> expression) Create a new aggregating sum expression

Constructors in com.mysema.query.group with parameters of type Expression

Constructor and Description
AbstractGroupExpression(Class<? super R> type, Expression<T> expr)
GAvg(Expression<T> expr)
GroupByBuilder(Expression<K> key) Create a new GroupByBuilder for the given key expression
GroupByProjection(Expression<K> key, Expression<?>... expressions)
GroupByProjection(Expression<K> key, Expression<?>... expressions)
GSum(Expression<T> expr)
QPair(Expression<K> key, Expression<V> value)
QPair(Expression<K> key, Expression<V> value)

Uses of Expression in com.mysema.query.jdo

Methods in com.mysema.query.jdo that return Expression

Modifier and Type	Method and Description
Expression<?>	JDOQLSerializer.getCandidatePath()

Methods in com.mysema.query.jdo with parameters of type Expression

Modifier and Type	Method and Description
com.mysema.commons.lang.CloseableIterator<Tuple>	AbstractJDOQuery.iterate(Expression<?>... args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	AbstractJDOQuery.iterate(Expression<RT> projection)
List<Tuple>	AbstractJDOQuery.list(Expression<?>... args)
<RT> List<RT>	AbstractJDOQuery.list(Expression<RT> expr)
SearchResults<Tuple>	AbstractJDOQuery.listResults(Expression<?>... args)
<RT> SearchResults<RT>	AbstractJDOQuery.listResults(Expression<RT> expr)
Tuple	AbstractJDOQuery.uniqueResult(Expression<?>... args)
<RT> RT	AbstractJDOQuery.uniqueResult(Expression<RT> expr)

Method parameters in com.mysema.query.jdo with type arguments of type Expression

Modifier and Type	Method and Description
protected void	JDOQLSerializer.visitOperation(Class<?> type, Operator<?> operator, List<? extends Expression<?>> args)

Constructors in com.mysema.query.jdo with parameters of type Expression

Constructor and Description
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

Modifier and Type	Method and Description
<T> JDOUpdateClause	JDOUpdateClause.set(Path<T> path, Expression<? extends T> expression)

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

Fields in com.mysema.query.jdo.sql declared as Expression

Modifier and Type	Field and Description
protected Expression<?>	AbstractSQLQuery.union

Methods in com.mysema.query.jdo.sql with parameters of type Expression

Modifier and Type	Method and Description
com.mysema.commons.lang.CloseableIterator<Tuple>	AbstractSQLQuery.iterate(Expression<?>... args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	AbstractSQLQuery.iterate(Expression<RT> projection)
List<Tuple>	AbstractSQLQuery.list(Expression<?>... args)
<RT> List<RT>	AbstractSQLQuery.list(Expression<RT> expr)
SearchResults<Tuple>	AbstractSQLQuery.listResults(Expression<?>... args)
<RT> SearchResults<RT>	AbstractSQLQuery.listResults(Expression<RT> expr)
Tuple	AbstractSQLQuery.uniqueResult(Expression<?>... args)
<RT> RT	AbstractSQLQuery.uniqueResult(Expression<RT> expr)

Uses of Expression in com.mysema.query.jpa

Methods in com.mysema.query.jpa that return Expression

Modifier and Type	Method and Description
static <RT> Expression<RT>	Conversions.convert(Expression<RT> expr)
<RT> Expression<RT>	JPAQueryMixin.convert(Expression<RT> expr, boolean forOrder)
static <RT> Expression<RT>	Conversions.convertForNativeQuery(Expression<RT> expr)
protected <D> Expression<D>	JPAQueryMixin.createAlias(Expression<?> expr, Path<?> alias)
protected Expression<?>	AbstractSQLQuery.extractEntityExpression(Expression<?> expr)

Methods in com.mysema.query.jpa that return types with arguments of type Expression

Modifier and Type	Method and Description
Map<Expression<?>,String>	NativeSQLSerializer.getAliases()

Methods in com.mysema.query.jpa with parameters of type Expression

Modifier and Type	Method and Description
static <RT> Expression<RT>	Conversions.convert(Expression<RT> expr)
<RT> Expression<RT>	JPAQueryMixin.convert(Expression<RT> expr, boolean forOrder)
static <RT> Expression<RT>	Conversions.convertForNativeQuery(Expression<RT> expr)
protected <D> Expression<D>	JPAQueryMixin.createAlias(Expression<?> expr, Path<?> alias)
protected Expression<?>	AbstractSQLQuery.extractEntityExpression(Expression<?> expr)
protected boolean	AbstractSQLQuery.isEntityExpression(Expression<?> expr)
Tuple	JPAQueryBase.uniqueResult(Expression<?>... args)

Method parameters in com.mysema.query.jpa with type arguments of type Expression

Modifier and Type	Method and Description
protected void	JPQLSerializer.visitOperation(Class<?> type, Operator<?> operator, List<? extends Expression<?>> args)
protected void	NativeSQLSerializer.visitOperation(Class<?> type, Operator<?> operator, List<? extends Expression<?>> args)

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

Methods in com.mysema.query.jpa.hibernate with parameters of type Expression

Modifier and Type	Method and Description
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<Tuple>	AbstractHibernateQuery.iterate(Expression<?>... args) Return the query results as an Iterator. Entities returned as results are initialized on demand.
<RT> com.mysema.commons.lang.CloseableIterator<RT>	AbstractHibernateQuery.iterate(Expression<RT> projection) Return the query results as an Iterator.
List<Tuple>	AbstractHibernateQuery.list(Expression<?>... args)
<RT> List<RT>	AbstractHibernateQuery.list(Expression<RT> expr)
SearchResults<Tuple>	AbstractHibernateQuery.listResults(Expression<?>... args)
<RT> SearchResults<RT>	AbstractHibernateQuery.listResults(Expression<RT> expr)
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<?> expr) Return the query results as ScrollableResults.
<T> HibernateUpdateClause	HibernateUpdateClause.set(Path<T> path, Expression<? extends T> expression)
Tuple	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

Modifier and Type	Method and Description
org.hibernate.Query	AbstractHibernateSQLQuery.createQuery(Expression<?>... args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	AbstractHibernateSQLQuery.iterate(Expression<RT> projection)
<RT> List<RT>	AbstractHibernateSQLQuery.list(Expression<RT> projection)
<RT> SearchResults<RT>	AbstractHibernateSQLQuery.listResults(Expression<RT> projection)
<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

Modifier and Type	Method and Description
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<Tuple>	AbstractJPAQuery.iterate(Expression<?>... args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	AbstractJPAQuery.iterate(Expression<RT> expr)
List<Tuple>	AbstractJPAQuery.list(Expression<?>... args)
<RT> List<RT>	AbstractJPAQuery.list(Expression<RT> expr)
SearchResults<Tuple>	AbstractJPAQuery.listResults(Expression<?>... args)
<RT> SearchResults<RT>	AbstractJPAQuery.listResults(Expression<RT> expr)
<T> JPAUpdateClause	JPAUpdateClause.set(Path<T> path, Expression<? extends T> expression)
<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

Modifier and Type	Method and Description
javax.persistence.Query	AbstractJPASQLQuery.createQuery(Expression<?>... args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	AbstractJPASQLQuery.iterate(Expression<RT> expr)
<RT> List<RT>	AbstractJPASQLQuery.list(Expression<RT> projection)
<RT> SearchResults<RT>	AbstractJPASQLQuery.listResults(Expression<RT> projection)
<RT> RT	AbstractJPASQLQuery.uniqueResult(Expression<RT> expr)

Uses of Expression in com.mysema.query.lucene

Classes in com.mysema.query.lucene that implement Expression

Modifier and Type	Class and Description
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

Modifier and Type	Method and Description
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

Modifier and Type	Class and Description
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

Modifier and Type	Method and Description
Object	MongodbSerializer.handle(Expression<?> expression)
static BooleanExpression	MongodbExpressions.near(Expression<Double[]> expr, double latVal, double longVal) Finds the closest points relative to the given location and orders the results with decreasing promimity

Method parameters in com.mysema.query.mongodb with type arguments of type Expression

Modifier and Type	Method and Description
protected com.mongodb.DBCursor	MongodbQuery.createCursor(com.mongodb.DBCollection collection, Predicate where, List<Expression<?>> projection, QueryModifiers modifiers, List<OrderSpecifier<?>> orderBy)

Uses of Expression in com.mysema.query.spatial

Classes in com.mysema.query.spatial that implement Expression

Modifier and Type	Class and Description
class	CurveExpression<T extends org.geolatte.geom.Geometry> A Curve is a 1-dimensional geometric object usually stored as a sequence of Points, with the subtype of Curve specifying the form of the interpolation between Points.
class	GeometryCollectionExpression<T extends org.geolatte.geom.GeometryCollection> A GeometryCollection is a geometric object that is a collection of some number of geometric objects.
class	GeometryExpression<T extends org.geolatte.geom.Geometry> Geometry is the root class of the hierarchy.
class	GeometryOperation<T extends org.geolatte.geom.Geometry>
class	LinearRingExpression<T extends org.geolatte.geom.LineString> A LinearRing is a LineString that is both closed and simple.
class	LineExpression<T extends org.geolatte.geom.LineString> A Line is a LineString with exactly 2 Points.
class	LineStringExpression<T extends org.geolatte.geom.LineString> A LineString is a Curve with linear interpolation between Points.
class	LineStringOperation<T extends org.geolatte.geom.LineString>
class	MultiCurveExpression<T extends org.geolatte.geom.GeometryCollection> A MultiCurve is a 1-dimensional GeometryCollection whose elements are Curves.
class	MultiLineStringExpression<T extends org.geolatte.geom.MultiLineString> A MultiLineString is a MultiCurve whose elements are LineStrings.
class	MultiPointExpression<T extends org.geolatte.geom.MultiPoint> A MultiPoint is a 0-dimensional GeometryCollection.
class	MultiPolygonExpression<T extends org.geolatte.geom.MultiPolygon> A MultiPolygon is a MultiSurface whose elements are Polygons.
class	MultiSurfaceExpression<T extends org.geolatte.geom.GeometryCollection> A MultiSurface is a 2-dimensional GeometryCollection whose elements are Surfaces, all using coordinates from the same coordinate reference system.
class	PointExpression<T extends org.geolatte.geom.Point> A Point is a 0-dimensional geometric object and represents a single location in coordinate space.
class	PointOperation<T extends org.geolatte.geom.Point>
class	PolygonExpression<T extends org.geolatte.geom.Polygon> A Polygon is a planar Surface defined by 1 exterior boundary and 0 or more interior boundaries.
class	PolygonOperation<T extends org.geolatte.geom.Polygon>
class	PolyhedralSurfaceExpression<T extends org.geolatte.geom.PolyHedralSurface> A PolyhedralSurface is a contiguous collection of polygons, which share common boundary segments.
class	SurfaceExpression<T extends org.geolatte.geom.Geometry> A Surface is a 2-dimensional geometric object.

Methods in com.mysema.query.spatial that return Expression

Modifier and Type	Method and Description
Expression<?>	PointOperation.getArg(int index)
Expression<?>	LineStringOperation.getArg(int index)
Expression<?>	GeometryOperation.getArg(int index)
Expression<?>	PolygonOperation.getArg(int index)

Methods in com.mysema.query.spatial that return types with arguments of type Expression

Modifier and Type	Method and Description
List<Expression<?>>	PointOperation.getArgs()
List<Expression<?>>	LineStringOperation.getArgs()
List<Expression<?>>	GeometryOperation.getArgs()
List<Expression<?>>	PolygonOperation.getArgs()

Methods in com.mysema.query.spatial with parameters of type Expression

Modifier and Type	Method and Description
static GeometryExpression<?>	GeometryExpressions.collect(Expression<? extends org.geolatte.geom.Geometry> expr1, Expression<? extends org.geolatte.geom.Geometry> expr2) Return a specified ST_Geometry value from a collection of other geometries.
static GeometryExpression<?>	GeometryExpressions.collect(Expression<? extends org.geolatte.geom.Geometry> expr1, Expression<? extends org.geolatte.geom.Geometry> expr2) Return a specified ST_Geometry value from a collection of other geometries.
static GeometryExpression<?>	GeometryExpressions.collect(Expression<? extends org.geolatte.geom.GeometryCollection> collection) Return a specified ST_Geometry value from a collection of other geometries.
BooleanExpression	GeometryExpression.contains(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns 1 (TRUE) if this geometric object “spatially contains” anotherGeometry.
static <D extends org.geolatte.geom.Geometry> GeometryOperation<D>	GeometryOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
static <D extends org.geolatte.geom.LineString> LineStringOperation<D>	LineStringOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
static <D extends org.geolatte.geom.Point> PointOperation<D>	PointOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
static <D extends org.geolatte.geom.Polygon> PolygonOperation<D>	PolygonOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
static <D extends org.geolatte.geom.Geometry> GeometryOperation<D>	GeometryOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one)
static <D extends org.geolatte.geom.LineString> LineStringOperation<D>	LineStringOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one)
static <D extends org.geolatte.geom.Point> PointOperation<D>	PointOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one)
static <D extends org.geolatte.geom.Polygon> PolygonOperation<D>	PolygonOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one)
static <D extends org.geolatte.geom.Geometry> GeometryOperation<D>	GeometryOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends org.geolatte.geom.Geometry> GeometryOperation<D>	GeometryOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends org.geolatte.geom.LineString> LineStringOperation<D>	LineStringOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends org.geolatte.geom.LineString> LineStringOperation<D>	LineStringOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends org.geolatte.geom.Point> PointOperation<D>	PointOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends org.geolatte.geom.Point> PointOperation<D>	PointOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends org.geolatte.geom.Polygon> PolygonOperation<D>	PolygonOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends org.geolatte.geom.Polygon> PolygonOperation<D>	PolygonOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
BooleanExpression	GeometryExpression.crosses(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns 1 (TRUE) if this geometric object “spatially crosses’ anotherGeometry.
GeometryExpression<org.geolatte.geom.Geometry>	GeometryExpression.difference(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns a geometric object that represents the Point set difference of this geometric object with anotherGeometry.
BooleanExpression	GeometryExpression.disjoint(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns 1 (TRUE) if this geometric object is “spatially disjoint” from anotherGeometry.
NumberExpression<Double>	GeometryExpression.distance(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns the shortest distance between any two Points in the two geometric objects as calculated in the spatial reference system of this geometric object.
NumberExpression<Double>	GeometryExpression.distanceSphere(Expression<? extends org.geolatte.geom.Geometry> geometry)
NumberExpression<Double>	GeometryExpression.distanceSpheroid(Expression<? extends org.geolatte.geom.Geometry> geometry)
static BooleanExpression	GeometryExpressions.dwithin(Expression<? extends org.geolatte.geom.Geometry> expr1, Expression<? extends org.geolatte.geom.Geometry> expr2, double distance) Returns true if the geometries are within the specified distance of one another.
static BooleanExpression	GeometryExpressions.dwithin(Expression<? extends org.geolatte.geom.Geometry> expr1, Expression<? extends org.geolatte.geom.Geometry> expr2, double distance) Returns true if the geometries are within the specified distance of one another.
static BooleanExpression	GeometryExpressions.dwithin(Expression<? extends org.geolatte.geom.Geometry> expr1, Expression<? extends org.geolatte.geom.Geometry> expr2, Expression<Double> distance) Returns true if the geometries are within the specified distance of one another.
static BooleanExpression	GeometryExpressions.dwithin(Expression<? extends org.geolatte.geom.Geometry> expr1, Expression<? extends org.geolatte.geom.Geometry> expr2, Expression<Double> distance) Returns true if the geometries are within the specified distance of one another.
static BooleanExpression	GeometryExpressions.dwithin(Expression<? extends org.geolatte.geom.Geometry> expr1, Expression<? extends org.geolatte.geom.Geometry> expr2, Expression<Double> distance) Returns true if the geometries are within the specified distance of one another.
BooleanExpression	GeometryExpression.eq(Expression<? super T> right)
static GeometryExpression<?>	GeometryExpressions.extent(Expression<? extends org.geolatte.geom.GeometryCollection> collection) Returns the bounding box that bounds rows of geometries.
static GeometryExpression<?>	GeometryExpressions.fromText(Expression<String> text) Return a specified ST_Geometry value from Well-Known Text representation (WKT).
GeometryExpression<org.geolatte.geom.Geometry>	GeometryExpression.intersection(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns a geometric object that represents the Point set intersection of this geometric object with anotherGeometry.
BooleanExpression	GeometryExpression.intersects(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns 1 (TRUE) if this geometric object “spatially intersects” anotherGeometry.
BooleanExpression	GeometryExpression.overlaps(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns 1 (TRUE) if this geometric object “spatially overlaps” anotherGeometry.
BooleanExpression	GeometryExpression.relate(Expression<? extends org.geolatte.geom.Geometry> geometry, String matrix) Returns 1 (TRUE) if this geometric object is spatially related to anotherGeometry by testing for intersections between the interior, boundary and exterior of the two geometric objects as specified by the values in the intersectionPatternMatrix.
static <T extends org.geolatte.geom.Geometry> GeometryExpression<T>	GeometryExpressions.setSRID(Expression<T> expr, int srid) Sets the SRID on a geometry to a particular integer value.
GeometryExpression<org.geolatte.geom.Geometry>	GeometryExpression.symDifference(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns a geometric object that represents the Point set symmetric difference of this geometric object with anotherGeometry.
BooleanExpression	GeometryExpression.touches(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns 1 (TRUE) if this geometric object “spatially touches” anotherGeometry.
static <T extends org.geolatte.geom.Geometry> GeometryExpression<T>	GeometryExpressions.translate(Expression<T> expr, float deltax, float deltay) Translates the geometry to a new location using the numeric parameters as offsets.
static <T extends org.geolatte.geom.Geometry> GeometryExpression<T>	GeometryExpressions.translate(Expression<T> expr, float deltax, float deltay, float deltaz) Translates the geometry to a new location using the numeric parameters as offsets.
GeometryExpression<org.geolatte.geom.Geometry>	GeometryExpression.union(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns a geometric object that represents the Point set union of this geometric object with anotherGeometry.
BooleanExpression	GeometryExpression.within(Expression<? extends org.geolatte.geom.Geometry> geometry) Returns 1 (TRUE) if this geometric object is “spatially within” anotherGeometry.

Constructors in com.mysema.query.spatial with parameters of type Expression

Constructor and Description
CurveExpression(Expression<T> mixin)
GeometryCollectionExpression(Expression<T> mixin)
GeometryExpression(Expression<T> mixin)
GeometryOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)
LinearRingExpression(Expression<T> mixin)
LineExpression(Expression<T> mixin)
LineStringExpression(Expression<T> mixin)
LineStringOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)
MultiCurveExpression(Expression<T> mixin)
MultiLineStringExpression(Expression<T> mixin)
MultiPointExpression(Expression<T> mixin)
MultiPolygonExpression(Expression<T> mixin)
MultiSurfaceExpression(Expression<T> mixin)
PointExpression(Expression<T> mixin)
PointOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)
PolygonExpression(Expression<T> mixin)
PolygonOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)
PolyhedralSurfaceExpression(Expression<T> mixin)
SurfaceExpression(Expression<T> mixin)

Constructor parameters in com.mysema.query.spatial with type arguments of type Expression

Constructor and Description
GeometryOperation(Class<T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)
LineStringOperation(Class<T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)
PointOperation(Class<T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)
PolygonOperation(Class<T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)

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

Classes in com.mysema.query.spatial.path that implement Expression

Modifier and Type	Class and Description
class	GeometryCollectionPath<T extends org.geolatte.geom.GeometryCollection>
class	GeometryPath<T extends org.geolatte.geom.Geometry>
class	LinearRingPath<T extends org.geolatte.geom.LinearRing>
class	LineStringPath<T extends org.geolatte.geom.LineString>
class	MultiLineStringPath<T extends org.geolatte.geom.MultiLineString>
class	MultiPointPath<T extends org.geolatte.geom.MultiPoint>
class	MultiPolygonPath<T extends org.geolatte.geom.MultiPolygon>
class	PointPath<T extends org.geolatte.geom.Point>
class	PolygonPath<T extends org.geolatte.geom.Polygon>
class	PolyhedralSurfacePath<T extends org.geolatte.geom.PolyHedralSurface>

Uses of Expression in com.mysema.query.sql

Subinterfaces of Expression in com.mysema.query.sql

Modifier and Type	Interface and Description
interface	RelationalPath<T> RelationalPath extends EntityPath to provide access to relational metadata

Classes in com.mysema.query.sql that implement Expression

Modifier and Type	Class and Description
class	QBeans Expression used to project a list of beans
class	RelationalFunctionCall<T> Represents a table valued function call
class	RelationalPathBase<T> RelationalPathBase is a base class for RelationalPath implementations
class	WindowFirstLast<T>
class	WindowFunction<A>
class	WindowOver<T> WindowOver is the first part of a WindowFunction construction
class	WithinGroup<T>
class	WithinGroup.OrderBy

Fields in com.mysema.query.sql declared as Expression

Modifier and Type	Field and Description
static Expression<Object[]>	SQLExpressions.all Wildcard expression
static Expression<Long>	SQLExpressions.countAll Wilcard count expression
static Expression<?>	SQLTemplates.RECURSIVE
protected Expression<?>	ProjectableSQLQuery.union

Methods in com.mysema.query.sql that return Expression

Modifier and Type	Method and Description
Expression<Tuple>	ForeignKey.getProjection()
Expression<Tuple>	PrimaryKey.getProjection()
static Expression<?>	UnionUtils.union(SubQueryExpression<?>[] union, boolean unionAll)
static Expression<?>	UnionUtils.union(SubQueryExpression<?>[] union, Path<?> alias, boolean unionAll)

Methods in com.mysema.query.sql that return types with arguments of type Expression

Modifier and Type	Method and Description
List<Expression<?>>	QBeans.getArgs()

Methods in com.mysema.query.sql with parameters of type Expression

Modifier and Type	Method and Description
Q	DetachableSQLQuery.addFlag(QueryFlag.Position position, Expression<?> flag) Add the given Expression as a query flag
Q	ProjectableSQLQuery.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	DetachableSQLQuery.addFlag(QueryFlag.Position position, String prefix, Expression<?> expr) Add the given prefix and expression as a general query flag
Q	ProjectableSQLQuery.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
R	WithBuilder.as(Expression<?> expr)
SimpleExpression<A>	WindowFunction.as(Expression<A> alias)
static <T extends Number> WindowOver<T>	SQLExpressions.avg(Expression<T> expr) Start a window function expression
static WindowOver<Double>	SQLExpressions.corr(Expression<? extends Number> expr1, Expression<? extends Number> expr2)
static WindowOver<Double>	SQLExpressions.corr(Expression<? extends Number> expr1, Expression<? extends Number> expr2)
static WindowOver<Long>	SQLExpressions.count(Expression<?> expr) Start a window function expression
static WindowOver<Long>	SQLExpressions.countDistinct(Expression<?> expr) Start a window function expression
static WindowOver<Double>	SQLExpressions.covarPop(Expression<? extends Number> expr1, Expression<? extends Number> expr2)
static WindowOver<Double>	SQLExpressions.covarPop(Expression<? extends Number> expr1, Expression<? extends Number> expr2)
static WindowOver<Double>	SQLExpressions.covarSamp(Expression<? extends Number> expr1, Expression<? extends Number> expr2)
static WindowOver<Double>	SQLExpressions.covarSamp(Expression<? extends Number> expr1, Expression<? extends Number> expr2)
static WithinGroup<Double>	SQLExpressions.cumeDist(Expression<?>... args)
static WithinGroup<Long>	SQLExpressions.denseRank(Expression<?>... args)
BooleanExpression	RelationalPathBase.eq(Expression<? super T> right) Compares the two relational paths using primary key columns
BooleanExpression	WindowFunction.eq(Expression<A> expr)
static Set<RelationalPath<?>>	RelationalPathExtractor.extract(Expression<?> expr)
static <T> WindowOver<T>	SQLExpressions.firstValue(Expression<T> expr) returns value evaluated at the row that is the first row of the window frame
WindowRows.BetweenAnd	WindowRows.Between.following(Expression<Integer> expr)
WindowFunction<A>	WindowRows.BetweenAnd.following(Expression<Integer> expr)
Q	DetachableSQLQuery.from(Expression<?>... args)
Q	ProjectableSQLQuery.from(Expression<?>... args)
Q	AbstractSQLQueryFactory.from(Expression<?>... args)
Q	SQLCommonQueryFactory.from(Expression<?>... from) Create a new SELECT query
Q	SQLCommonQuery.from(Expression<?>... o) Defines the sources of the query
Q	DetachableSQLQuery.from(Expression<?> arg)
Q	ProjectableSQLQuery.from(Expression<?> arg)
Q	AbstractSQLQueryFactory.from(Expression<?> from)
Q	SQLCommonQueryFactory.from(Expression<?> from) Create a new SELECT query
ResultSet	AbstractSQLQuery.getResults(Expression<?>... exprs) Get the results as an JDBC result set
SQLBindings	DetachableSQLQuery.getSQL(Expression<?>... exprs) Get the query as an SQL query string and bindings
SQLBindings	ProjectableSQLQuery.getSQL(Expression<?>... exprs) Get the query as an SQL query string and bindings
Union<RT>	Union.groupBy(Expression<?>... o) Defines the grouping/aggregation expressions
Union<RT>	UnionImpl.groupBy(Expression<?>... o)
com.mysema.commons.lang.CloseableIterator<Tuple>	ProjectableSQLQuery.iterate(Expression<?>... args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	AbstractSQLQuery.iterate(Expression<RT> expr)
static <T> WindowOver<T>	SQLExpressions.lag(Expression<T> expr) expr evaluated at the row that is one row before the current row within the partition
static <T> WindowOver<T>	SQLExpressions.lastValue(Expression<T> expr) returns value evaluated at the row that is the last row of the window frame
static <T> WindowOver<T>	SQLExpressions.lead(Expression<T> expr) expr evaluated at the row that is one row after the current row within the partition;
static StringExpression	SQLExpressions.left(Expression<String> lhs, Expression<Integer> rhs) Get the rhs leftmost characters of lhs
static StringExpression	SQLExpressions.left(Expression<String> lhs, Expression<Integer> rhs) Get the rhs leftmost characters of lhs
static StringExpression	SQLExpressions.left(Expression<String> lhs, int rhs) Get the rhs leftmost characters of lhs
List<Tuple>	ProjectableSQLQuery.list(Expression<?>... args)
<RT> List<RT>	AbstractSQLQuery.list(Expression<RT> expr)
static WithinGroup<Object>	SQLExpressions.listagg(Expression<?> expr, String delimiter)
SearchResults<Tuple>	ProjectableSQLQuery.listResults(Expression<?>... args)
<RT> SearchResults<RT>	AbstractSQLQuery.listResults(Expression<RT> expr)
static <T extends Comparable> WindowOver<T>	SQLExpressions.max(Expression<T> expr) Start a window function expression
static <T extends Comparable> WindowOver<T>	SQLExpressions.min(Expression<T> expr) Start a window function expression
BooleanExpression	RelationalPathBase.ne(Expression<? super T> right) Compares the two relational paths using primary key columns
BooleanExpression	WindowFunction.ne(Expression<A> expr)
static <T> WindowOver<T>	SQLExpressions.nthValue(Expression<T> measureExpr, Expression<? extends Number> n)
static <T> WindowOver<T>	SQLExpressions.nthValue(Expression<T> measureExpr, Expression<? extends Number> n)
static <T> WindowOver<T>	SQLExpressions.nthValue(Expression<T> measureExpr, Number n)
WindowFunction<A>	WindowFunction.partitionBy(Expression<?>... partitionBy)
WindowFunction<A>	WindowFunction.partitionBy(Expression<?> partitionBy)
static <T extends Number> WithinGroup<T>	SQLExpressions.percentileCont(Expression<T> arg)
static <T extends Number> WithinGroup<T>	SQLExpressions.percentileDisc(Expression<T> arg)
static WithinGroup<Double>	SQLExpressions.percentRank(Expression<?>... args)
WindowFunction<A>	WindowRows.preceding(Expression<Integer> expr)
WindowRows.BetweenAnd	WindowRows.Between.preceding(Expression<Integer> expr)
WindowFunction<A>	WindowRows.BetweenAnd.preceding(Expression<Integer> expr)
static WithinGroup<Long>	SQLExpressions.rank(Expression<?>... args)
static <T> WindowOver<T>	SQLExpressions.ratioToReport(Expression<T> expr) computes the ratio of a value to the sum of a set of values.
static WindowOver<Double>	SQLExpressions.regrAvgx(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrAvgx(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrAvgy(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrAvgy(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrCount(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrCount(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrIntercept(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrIntercept(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrR2(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrR2(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrSlope(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrSlope(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrSxx(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrSxx(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrSxy(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrSxy(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrSyy(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static WindowOver<Double>	SQLExpressions.regrSyy(Expression<? extends Number> arg1, Expression<? extends Number> arg2)
static StringExpression	SQLExpressions.right(Expression<String> lhs, Expression<Integer> rhs) Get the rhs leftmost characters of lhs
static StringExpression	SQLExpressions.right(Expression<String> lhs, Expression<Integer> rhs) Get the rhs leftmost characters of lhs
static StringExpression	SQLExpressions.right(Expression<String> lhs, int rhs) Get the rhs rightmost characters of lhs
void	SQLSerializer.serializeUnion(Expression<?> union, QueryMetadata metadata, boolean unionAll)
static <T extends Number> WindowOver<T>	SQLExpressions.stddev(Expression<T> expr) returns the sample standard deviation of expr, a set of numbers.
static <T extends Number> WindowOver<T>	SQLExpressions.stddevDistinct(Expression<T> expr)
static <T extends Number> WindowOver<T>	SQLExpressions.stddevPop(Expression<T> expr) returns the population standard deviation and returns the square root of the population variance.
static <T extends Number> WindowOver<T>	SQLExpressions.stddevSamp(Expression<T> expr) returns the cumulative sample standard deviation and returns the square root of the sample variance.
SQ	AbstractSQLQueryFactory.subQuery(Expression<?> from)
SQ	SQLCommonQueryFactory.subQuery(Expression<?> from)
static <T extends Number> WindowOver<T>	SQLExpressions.sum(Expression<T> expr) Start a window function expression
Tuple	ProjectableSQLQuery.uniqueResult(Expression<?>... args)
<RT> RT	AbstractSQLQuery.uniqueResult(Expression<RT> expr)
<RT> RT	ProjectableSQLQuery.uniqueResult(Expression<RT> expr)
static <T extends Number> WindowOver<T>	SQLExpressions.variance(Expression<T> expr) returns the variance of expr
static <T extends Number> WindowOver<T>	SQLExpressions.varPop(Expression<T> expr) returns the population variance of a set of numbers after discarding the nulls in this set.
static <T extends Number> WindowOver<T>	SQLExpressions.varSamp(Expression<T> expr) returns the sample variance of a set of numbers after discarding the nulls in this set.
Q	DetachableSQLQuery.with(Path<?> alias, Expression<?> query)
Q	ProjectableSQLQuery.with(Path<?> alias, Expression<?> query)
Q	SQLCommonQuery.with(Path<?> alias, Expression<?> query) Adds a common table expression
Q	DetachableSQLQuery.withRecursive(Path<?> alias, Expression<?> query)
Q	ProjectableSQLQuery.withRecursive(Path<?> alias, Expression<?> query)
Q	SQLCommonQuery.withRecursive(Path<?> alias, Expression<?> query) Adds a common table expression

Method parameters in com.mysema.query.sql with type arguments of type Expression

Modifier and Type	Method and Description
void	SQLListener.notifyInsert(RelationalPath<?> entity, QueryMetadata md, List<Path<?>> columns, List<Expression<?>> values, SubQueryExpression<?> subQuery) Notify about an insertion
void	SQLListeners.notifyInsert(RelationalPath<?> entity, QueryMetadata md, List<Path<?>> columns, List<Expression<?>> values, SubQueryExpression<?> subQuery)
void	SQLListener.notifyMerge(RelationalPath<?> entity, QueryMetadata md, List<Path<?>> keys, List<Path<?>> columns, List<Expression<?>> values, SubQueryExpression<?> subQuery) Notify about a merge
void	SQLListeners.notifyMerge(RelationalPath<?> entity, QueryMetadata md, List<Path<?>> keys, List<Path<?>> columns, List<Expression<?>> values, SubQueryExpression<?> subQuery)
void	SQLListener.notifyUpdate(RelationalPath<?> entity, QueryMetadata md, List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates) Notify about an update operation
void	SQLListeners.notifyUpdate(RelationalPath<?> entity, QueryMetadata md, List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates)
void	SQLSerializer.serializeInsert(QueryMetadata metadata, RelationalPath<?> entity, List<Path<?>> columns, List<Expression<?>> values, SubQueryExpression<?> subQuery)
void	SQLTemplates.serializeInsert(QueryMetadata metadata, RelationalPath<?> entity, List<Path<?>> columns, List<Expression<?>> values, SubQueryExpression<?> subQuery, SQLSerializer context) template method for INSERT serialization
void	SQLSerializer.serializeMerge(QueryMetadata metadata, RelationalPath<?> entity, List<Path<?>> keys, List<Path<?>> columns, List<Expression<?>> values, SubQueryExpression<?> subQuery)
void	SQLTemplates.serializeMerge(QueryMetadata metadata, RelationalPath<?> entity, List<Path<?>> keys, List<Path<?>> columns, List<Expression<?>> values, SubQueryExpression<?> subQuery, SQLSerializer context) template method for MERGE serialization
void	SQLSerializer.serializeUpdate(QueryMetadata metadata, RelationalPath<?> entity, List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates)
void	SQLTemplates.serializeUpdate(QueryMetadata metadata, RelationalPath<?> entity, List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates, SQLSerializer context) template method for UPDATE serialization
void	SQLServer2005Templates.serializeUpdate(QueryMetadata metadata, RelationalPath<?> entity, List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates, SQLSerializer context)
void	OracleTemplates.serializeUpdate(QueryMetadata metadata, RelationalPath<?> entity, List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates, SQLSerializer context)
protected void	SQLSerializer.visitOperation(Class<?> type, Operator<?> operator, List<? extends Expression<?>> args)

Constructors in com.mysema.query.sql with parameters of type Expression

Constructor and Description
WindowFunction(Expression<A> expr)
WindowOver(Class<T> type, Operator<? super T> op, Expression<?> arg)
WindowOver(Class<T> type, Operator<? super T> op, Expression<?> arg1, Expression<?> arg2)
WindowOver(Class<T> type, Operator<? super T> op, Expression<?> arg1, Expression<?> arg2)
WithBuilder(QueryMixin<R> queryMixin, Expression<?> alias)
WithinGroup(Class<T> type, Operator<? super T> op, Expression<?>... args)
WithinGroup(Class<T> type, Operator<? super T> op, Expression<?> arg)
WithinGroup(Class<T> type, Operator<? super T> op, Expression<?> arg1, Expression<?> arg2)
WithinGroup(Class<T> type, Operator<? super T> op, Expression<?> arg1, Expression<?> arg2)

Constructor parameters in com.mysema.query.sql with type arguments of type Expression

Constructor and Description
UnionImpl(Q query, List<? extends Expression<?>> projection)

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

Methods in com.mysema.query.sql.dml that return types with arguments of type Expression

Modifier and Type	Method and Description
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>>	SQLUpdateBatch.getUpdates()
List<Expression<?>>	SQLInsertBatch.getValues()
List<Expression<?>>	SQLMergeBatch.getValues()

Methods in com.mysema.query.sql.dml with parameters of type Expression

Modifier and Type	Method and Description
SQLDeleteClause	SQLDeleteClause.addFlag(QueryFlag.Position position, Expression<?> flag) Add the given Expression at the given position as a query flag
SQLUpdateClause	SQLUpdateClause.addFlag(QueryFlag.Position position, Expression<?> flag) Add the given Expression at the given position as a query flag
SQLMergeClause	SQLMergeClause.addFlag(QueryFlag.Position position, Expression<?> flag) Add the given Expression at the given position as a query flag
SQLInsertClause	SQLInsertClause.addFlag(QueryFlag.Position position, Expression<?> flag) Add the given Expression at the given position as a query flag
<T> SQLUpdateClause	SQLUpdateClause.set(Path<T> path, Expression<? extends T> expression)
<T> SQLMergeClause	SQLMergeClause.set(Path<T> path, Expression<? extends T> expression)
<T> SQLInsertClause	SQLInsertClause.set(Path<T> path, Expression<? extends T> expression)

Constructor parameters in com.mysema.query.sql.dml with type arguments of type Expression

Constructor and Description
SQLInsertBatch(List<Path<?>> c, List<Expression<?>> v, SubQueryExpression<?> sq)
SQLMergeBatch(List<Path<?>> k, List<Path<?>> c, List<Expression<?>> v, SubQueryExpression<?> sq)
SQLUpdateBatch(QueryMetadata metadata, List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates)

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

Methods in com.mysema.query.sql.mysql with parameters of type Expression

Modifier and Type	Method and Description
SQLInsertClause	MySQLQueryFactory.insertOnDuplicateKeyUpdate(RelationalPath<?> entity, Expression<?> clause)

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

Methods in com.mysema.query.sql.oracle with parameters of type Expression

Modifier and Type	Method and Description
OracleQuery	OracleQuery.orderSiblingsBy(Expression<?> path)

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

Classes in com.mysema.query.sql.spatial that implement Expression

Modifier and Type	Class and Description
class	QSpatialRefSys QSpatialRefSys is a Querydsl query type for SpatialRefSys
class	RelationalPathSpatial<T>

Uses of Expression in com.mysema.query.support

Classes in com.mysema.query.support that implement Expression

Modifier and Type	Class and Description
class	EnumConversion<T> EnumConversion ensures that the results of an enum projection confirm to the type of the projection expression
class	NumberConversion<T> NumberConversion ensures that the results of a numeric projection confirm to the type of the projection expression
class	NumberConversions<T> NumberConversions ensures that the results of a projection involving numeric expressions confirm to the types of the numeric expressions

Methods in com.mysema.query.support that return Expression

Modifier and Type	Method and Description
<E> Expression<E>	QueryMixin.addProjection(Expression<E> e)
static <T> Expression<T>	Expressions.constant(T value) Create a Constant expression for the given value
<RT> Expression<RT>	QueryMixin.convert(Expression<RT> expr, boolean forOrder)
protected <D> Expression<D>	QueryMixin.createAlias(Expression<?> expr, Path<?> alias)
Expression<Tuple>	QueryMixin.createProjection(Expression<?>[] args)
Expression<?>	ListAccessVisitor.visit(Constant<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(Constant<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(Constant<?> expr, Void context)
Expression<?>	ListAccessVisitor.visit(FactoryExpression<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(FactoryExpression<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(FactoryExpression<?> expr, Void context)
Expression<?>	ListAccessVisitor.visit(Operation<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(Operation<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(Operation<?> expr, Void context)
Expression<?>	ListAccessVisitor.visit(ParamExpression<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(ParamExpression<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(ParamExpression<?> expr, Void context)
Expression<?>	ListAccessVisitor.visit(Path<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(Path<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(Path<?> expr, Void context)
Expression<?>	ListAccessVisitor.visit(SubQueryExpression<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(SubQueryExpression<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(SubQueryExpression<?> expr, Void context)
Expression<?>	ListAccessVisitor.visit(TemplateExpression<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(TemplateExpression<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(TemplateExpression<?> expr, Void context)

Methods in com.mysema.query.support that return types with arguments of type Expression

Modifier and Type	Method and Description
List<Expression<?>>	NumberConversion.getArgs()
List<Expression<?>>	NumberConversions.getArgs()
List<Expression<?>>	EnumConversion.getArgs()

Methods in com.mysema.query.support with parameters of type Expression

Modifier and Type	Method and Description
void	OrderedQueryMetadata.addJoin(JoinType joinType, Expression<?> expr)
T	QueryMixin.addJoin(JoinType joinType, Expression<?> target)
T	QueryMixin.addProjection(Expression<?>... o)
<E> Expression<E>	QueryMixin.addProjection(Expression<E> e)
static <D> SimpleExpression<D>	Expressions.as(Expression<D> source, Path<D> alias)
static <D> SimpleExpression<D>	Expressions.as(Expression<D> source, String alias) Create the alias expression source as alias
static BooleanExpression	Expressions.booleanOperation(Operator<Boolean> operation, Expression<?>... args) Create a new Boolean operation
static <T extends Comparable<?>> ComparableExpression<T>	Expressions.comparableOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args) Create a new Operation expression
<RT> Expression<RT>	QueryMixin.convert(Expression<RT> expr, boolean forOrder)
protected <D> Expression<D>	QueryMixin.createAlias(Expression<?> expr, Path<?> alias)
Expression<Tuple>	QueryMixin.createProjection(Expression<?>[] args)
static <T extends Comparable<?>> DateExpression<T>	Expressions.dateOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args) Create a new Operation expression
static <T extends Comparable<?>> DateTimeExpression<T>	Expressions.dateTimeOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args) Create a new Operation expression
static <T> DslExpression<T>	Expressions.dslOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args) Create a new Operation expression
T	QueryMixin.from(Expression<?>... args)
T	QueryMixin.from(Expression<?> arg)
T	QueryMixin.fullJoin(Expression<?> target)
<P> T	QueryMixin.fullJoin(Expression<P> target, Path<P> alias)
T	QueryMixin.groupBy(Expression<?>... o)
Q	QueryBase.groupBy(Expression<?>... o) Add grouping/aggregation expressions
T	QueryMixin.groupBy(Expression<?> e)
Q	QueryBase.groupBy(Expression<?> e) Add a single grouping expression
S	SerializerBase.handle(Expression<?> expr)
S	SerializerBase.handle(String sep, Expression<?>[] expressions)
<P> T	QueryMixin.innerJoin(Expression<P> target)
<P> T	QueryMixin.innerJoin(Expression<P> target, Path<P> alias)
com.mysema.commons.lang.CloseableIterator<Tuple>	ProjectableAdapter.iterate(Expression<?>... args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	ProjectableAdapter.iterate(Expression<RT> projection)
<P> T	QueryMixin.join(Expression<P> target)
<P> T	QueryMixin.join(Expression<P> target, Path<P> alias)
<P> T	QueryMixin.leftJoin(Expression<P> target)
<P> T	QueryMixin.leftJoin(Expression<P> target, Path<P> alias)
List<Tuple>	ProjectableQuery.list(Expression<?>... args)
ListSubQuery<Tuple>	DetachableMixin.list(Expression<?>... args)
ListSubQuery<Tuple>	DetachableQuery.list(Expression<?>... args)
ListSubQuery<Tuple>	DetachableAdapter.list(Expression<?>... args)
List<Tuple>	ProjectableAdapter.list(Expression<?>[] args)
ListSubQuery<Tuple>	DetachableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
ListSubQuery<Tuple>	DetachableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
ListSubQuery<Tuple>	DetachableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
<RT> List<RT>	ProjectableQuery.list(Expression<RT> projection)
<RT> ListSubQuery<RT>	DetachableMixin.list(Expression<RT> projection)
<RT> ListSubQuery<RT>	DetachableQuery.list(Expression<RT> projection)
<RT> ListSubQuery<RT>	DetachableAdapter.list(Expression<RT> projection)
<RT> List<RT>	ProjectableAdapter.list(Expression<RT> projection)
SearchResults<Tuple>	ProjectableAdapter.listResults(Expression<?>... args)
<RT> SearchResults<RT>	ProjectableAdapter.listResults(Expression<RT> expr)
<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)
<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)
static <T extends Number & Comparable<?>> NumberExpression<T>	Expressions.numberOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args) Create a new Operation expression
static <T> SimpleExpression<T>	Expressions.operation(Class<T> type, Operator<? super T> operator, Expression<?>... args) Create a new Operation expression
static BooleanExpression	Expressions.predicate(Operator<Boolean> operation, Expression<?>... args) Create a new Predicate operation
<P> T	QueryMixin.rightJoin(Expression<P> target)
<P> T	QueryMixin.rightJoin(Expression<P> target, Path<P> alias)
Tuple	ProjectableQuery.singleResult(Expression<?>... args)
Tuple	ProjectableAdapter.singleResult(Expression<?>... args)
<RT> RT	ProjectableQuery.singleResult(Expression<RT> expr)
<RT> RT	ProjectableAdapter.singleResult(Expression<RT> expr)
static StringExpression	Expressions.stringOperation(Operator<? super String> operator, Expression<?>... args) Create a new Operation expression
static <T extends Comparable<?>> TimeExpression<T>	Expressions.timeOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args) Create a new Operation expression
SimpleSubQuery<Tuple>	DetachableMixin.unique(Expression<?>... args)
SimpleSubQuery<Tuple>	DetachableQuery.unique(Expression<?>... args)
SimpleSubQuery<Tuple>	DetachableAdapter.unique(Expression<?>... args)
SimpleSubQuery<Tuple>	DetachableAdapter.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
SimpleSubQuery<Tuple>	DetachableAdapter.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
SimpleSubQuery<Tuple>	DetachableAdapter.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
<RT> SimpleSubQuery<RT>	DetachableMixin.unique(Expression<RT> projection)
<RT> SimpleSubQuery<RT>	DetachableQuery.unique(Expression<RT> projection)
<RT> SimpleSubQuery<RT>	DetachableAdapter.unique(Expression<RT> projection)
Tuple	ProjectableAdapter.uniqueResult(Expression<?>... args)
<RT> RT	ProjectableAdapter.uniqueResult(Expression<RT> expr)

Method parameters in com.mysema.query.support with type arguments of type Expression

Modifier and Type	Method and Description
protected void	SerializerBase.visitOperation(Class<?> type, Operator<?> operator, List<? extends Expression<?>> args)

Constructors in com.mysema.query.support with parameters of type Expression

Constructor and Description
EnumConversion(Expression<T> expr)
NumberConversion(Expression<T> expr)
SimpleProjectableAdapter(Q query, Expression<T> projection)
SimpleProjectableAdapter(SimpleQuery<?> query, Projectable projectable, Expression<T> projection)

Uses of Expression in com.mysema.query.types

Subinterfaces of Expression in com.mysema.query.types

Modifier and Type	Interface and Description
interface	CollectionExpression<T extends Collection<E>,E> CollectionExpression represents 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 Map typed expressions
interface	Operation<T> Operation represents an operation with operator and arguments
interface	ParametrizedExpression<T> ParametrizedExpression is a common interface for expressions with generic type parameters
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

Modifier and Type	Class and Description
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 immutable Expression implementations
class	FactoryExpressionBase<T> Common superclass for FactoryExpression implementations
static class	FactoryExpressionUtils.FactoryExpressionAdapter<T>
class	MappingProjection<T> Projection template that allows implementing arbitrary mapping of rows to result objects.
class	MutableExpressionBase<T> MutableExpressionBase is the base class for mutable Expression implementations
class	NullExpression<T> NullExpression defines a general null expression
class	OperationImpl<T> OperationImpl is the default implementation of the Operation interface
class	ParamExpressionImpl<T> ParamExpressionImpl defines a parameter in a query with an optional name
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	QList QList represents a projection of type List
class	QMap QMap represents a projection of type Map
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

Methods in com.mysema.query.types that return Expression

Modifier and Type	Method and Description
static <T> Expression<T>	ExpressionUtils.all(CollectionExpression<?,? super T> col)
static <T> Expression<T>	ExpressionUtils.any(CollectionExpression<?,? super T> col)
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<T>	ConstructorExpression.as(Path<T> alias) Create an alias for the expression
Expression<T>	QBean.as(Path<T> alias) Create an alias for the expression
Expression<T>	ConstructorExpression.as(String alias) Create an alias for the expression
Expression<T>	QBean.as(String alias) Create an alias for the expression
static Expression<Long>	ExpressionUtils.count(Expression<?> source)
static <C> Expression<C>	TemplateExpressionImpl.create(Class<C> cl, String template)
static <C> Expression<C>	TemplateExpressionImpl.create(Class<C> cl, String template, Object... args)
static <C> Expression<C>	TemplateExpressionImpl.create(Class<C> cl, String template, Object one)
static <C> Expression<C>	TemplateExpressionImpl.create(Class<C> cl, String template, Object one, Object two)
static <C> Expression<C>	TemplateExpressionImpl.create(Class<C> cl, Template template, Object... args)
static <T> Expression<T>	ExpressionUtils.extract(Expression<T> expr) Get the potentially wrapped expression
Expression<?>	Operation.getArg(int index) Get the argument with the given index
Expression<?>	OperationImpl.getArg(int i)
Expression<T>	ProjectionRole.getProjection() Return the custom projection
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<String>	ExpressionUtils.likeToRegex(Expression<String> expr, boolean matchStartAndEnd)
static <T> Expression<T>	ExpressionUtils.list(Class<T> clazz, Expression<?>... exprs)
static <T> Expression<T>	ExpressionUtils.list(Class<T> clazz, List<? extends Expression<?>> exprs)
static Expression<String>	ExpressionUtils.regexToLike(Expression<String> expr)

Methods in com.mysema.query.types that return types with arguments of type Expression

Modifier and Type	Method and Description
static com.google.common.collect.ImmutableList<Expression<?>>	ExpressionUtils.distinctList(Expression<?>... args) Get a distinct list of the given args
static com.google.common.collect.ImmutableList<Expression<?>>	ExpressionUtils.distinctList(Expression<?>[]... args) Get a distinct list of the concatenated array contents
List<Expression<?>>	FactoryExpressionUtils.FactoryExpressionAdapter.getArgs()
List<Expression<?>>	Operation.getArgs() Get the arguments of this operation
List<Expression<?>>	ConstructorExpression.getArgs()
List<Expression<?>>	FactoryExpression.getArgs() Get the invocation arguments
List<Expression<?>>	QList.getArgs()
List<Expression<?>>	MappingProjection.getArgs()
List<Expression<?>>	ArrayConstructorExpression.getArgs()
List<Expression<?>>	QMap.getArgs()
List<Expression<?>>	QBean.getArgs()
List<Expression<?>>	QTuple.getArgs()
List<Expression<?>>	OperationImpl.getArgs()
Map<Expression<?>,?>	QMap.newInstance(Object... args)
Set<Expression<?>>	ValidatingVisitor.visit(Constant<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(FactoryExpression<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(Operation<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(ParamExpression<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(Path<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(SubQueryExpression<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(TemplateExpression<?> expr, Set<Expression<?>> known)

Methods in com.mysema.query.types with parameters of type Expression

Modifier and Type	Method and Description
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
static Expression<Long>	ExpressionUtils.count(Expression<?> source)
static <RT> Operation<RT>	OperationImpl.create(Class<? extends RT> type, Operator<? super RT> operator, Expression<?> one)
static <RT> Operation<RT>	OperationImpl.create(Class<? extends RT> type, Operator<? super RT> operator, Expression<?> one, Expression<?> two)
static <RT> Operation<RT>	OperationImpl.create(Class<? extends RT> type, Operator<? super RT> operator, Expression<?> one, Expression<?> two)
static <D> ConstructorExpression<D>	ConstructorExpression.create(Class<D> type, Expression<?>... args)
static PredicateOperation	PredicateOperation.create(Operator<Boolean> operator, Expression<?> one)
static PredicateOperation	PredicateOperation.create(Operator<Boolean> operator, Expression<?> one, Expression<?> two)
static PredicateOperation	PredicateOperation.create(Operator<Boolean> operator, Expression<?> one, Expression<?> two)
static com.google.common.collect.ImmutableList<Expression<?>>	ExpressionUtils.distinctList(Expression<?>... args) Get a distinct list of the given args
static com.google.common.collect.ImmutableList<Expression<?>>	ExpressionUtils.distinctList(Expression<?>[]... args) Get a distinct list of the concatenated array contents
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> Expression<T>	ExpressionUtils.extract(Expression<T> expr) Get the potentially wrapped 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) Create a new PathMetadata for indexed array access
static PathMetadata<Integer>	PathMetadataFactory.forListAccess(Path<?> parent, Expression<Integer> index) Create a new PathMetadata for indexed list access
static <KT> PathMetadata<KT>	PathMetadataFactory.forMapAccess(Path<?> parent, Expression<KT> key) Create a new PathMetadata for key based map access
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 Expression<String>	ExpressionUtils.likeToRegex(Expression<String> expr, boolean matchStartAndEnd)
static <T> Expression<T>	ExpressionUtils.list(Class<T> clazz, Expression<?>... exprs)
static QMap	Projections.map(Expression<?>... exprs) Create a Map typed projection for the given expressions
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
protected void	QBean.propertyNotFound(Expression<?> expr, String property)
static Expression<String>	ExpressionUtils.regexToLike(Expression<String> expr)
static QTuple	Projections.tuple(Expression<?>... exprs) Create a Tuple typed projection for the given expressions
protected void	QBean.typeMismatch(Class<?> type, Expression<?> expr)

Method parameters in com.mysema.query.types with type arguments of type Expression

Modifier and Type	Method and Description
static <T> Expression<T>	ExpressionUtils.list(Class<T> clazz, List<? extends Expression<?>> exprs)
Set<Expression<?>>	ValidatingVisitor.visit(Constant<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(FactoryExpression<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(Operation<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(ParamExpression<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(Path<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(SubQueryExpression<?> expr, Set<Expression<?>> known)
Set<Expression<?>>	ValidatingVisitor.visit(TemplateExpression<?> expr, Set<Expression<?>> known)
static <T> FactoryExpression<T>	FactoryExpressionUtils.wrap(FactoryExpression<T> expr, List<Expression<?>> conversions)
static FactoryExpression<?>	FactoryExpressionUtils.wrap(List<? extends Expression<?>> projection)

Constructors in com.mysema.query.types with parameters of type Expression

Constructor and Description
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) Create a new MappingProjection instance
MappingProjection(Class<? super T> type, Expression<?>[]... args) Create a new MappingProjection instance
OperationImpl(Class<? extends T> type, Operator<? super T> operator, Expression<?>... args)
OrderSpecifier(Order order, Expression<T> target)
OrderSpecifier(Order order, Expression<T> target, OrderSpecifier.NullHandling nullhandling)
QBean(Class<T> type, boolean fieldAccess, Expression<?>... args) Create a new QBean instance
QBean(Class<T> type, Expression<?>... args) Create a new QBean instance
QBean(Path<T> type, boolean fieldAccess, Expression<?>... args) Create a new QBean instance
QBean(Path<T> type, Expression<?>... args) Create a new QBean instance
QList(Expression<?>... args) Create a new QList instance
QList(Expression<?>[]... args) Create a new QMap instance
QMap(Expression<?>... args) Create a new QMap instance
QMap(Expression<?>[]... args) Create a new QMap instance
QTuple(Expression<?>... args) Create a new QTuple instance
QTuple(Expression<?>[]... args) Create a new QTuple instance

Constructor parameters in com.mysema.query.types with type arguments of type Expression

Constructor and Description
ConstructorExpression(Class<T> type, Class<?>[] paramTypes, com.google.common.collect.ImmutableList<Expression<?>> args)
OperationImpl(Class<? extends T> type, Operator<? super T> operator, com.google.common.collect.ImmutableList<Expression<?>> args)
PredicateOperation(Operator<Boolean> operator, com.google.common.collect.ImmutableList<Expression<?>> args)
QBean(Class<T> type, boolean fieldAccess, Map<String,? extends Expression<?>> bindings) Create a new QBean instance
QBean(Class<T> type, Map<String,? extends Expression<?>> bindings) Create a new QBean instance
QBean(Path<T> type, boolean fieldAccess, Map<String,? extends Expression<?>> bindings) Create a new QBean instance
QBean(Path<T> type, Map<String,? extends Expression<?>> bindings) Create a new QBean instance
QList(com.google.common.collect.ImmutableList<Expression<?>> args) Create a new QList instance
QMap(com.google.common.collect.ImmutableList<Expression<?>> args) Create a new QMap instance
QTuple(com.google.common.collect.ImmutableList<Expression<?>> args) Create a new QTuple instance

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

Classes in com.mysema.query.types.expr with type parameters of type Expression

Modifier and Type	Class and Description
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

Modifier and Type	Interface and Description
interface	ArrayExpression<A,T> ArrayExpression defines an interface for array typed expression
interface	ListExpression<E,Q extends SimpleExpression<? super E>> ListExpression represents List typed expressions

Classes in com.mysema.query.types.expr that implement Expression

Modifier and Type	Class and Description
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	CollectionOperation<E>
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	DslExpression<T> DslExpression is the base class for DSL expressions, but SimpleExpression is the base class for scalar Expressions
class	DslOperation<T> DslOperation represents a simple operation expression
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

Modifier and Type	Field and Description
static Expression<Object[]>	Wildcard.all Wilcard expression (*) for all columns
protected Expression<T>	DslExpression.mixin

Methods in com.mysema.query.types.expr that return Expression

Modifier and Type	Method and Description
Expression<?>	NumberOperation.getArg(int index)
Expression<?>	DateTimeOperation.getArg(int index)
Expression<?>	StringOperation.getArg(int index)
Expression<?>	BooleanOperation.getArg(int index)
Expression<?>	TimeOperation.getArg(int index)
Expression<?>	EnumOperation.getArg(int index)
Expression<?>	ComparableOperation.getArg(int index)
Expression<?>	DslOperation.getArg(int index)
Expression<?>	SimpleOperation.getArg(int index)
Expression<?>	DateOperation.getArg(int index)

Methods in com.mysema.query.types.expr that return types with arguments of type Expression

Modifier and Type	Method and Description
List<Expression<?>>	NumberOperation.getArgs()
List<Expression<?>>	DateTimeOperation.getArgs()
List<Expression<?>>	StringOperation.getArgs()
List<Expression<?>>	BooleanOperation.getArgs()
List<Expression<?>>	TimeOperation.getArgs()
List<Expression<?>>	EnumOperation.getArgs()
List<Expression<?>>	ComparableOperation.getArgs()
List<Expression<?>>	DslOperation.getArgs()
List<Expression<?>>	SimpleOperation.getArgs()
List<Expression<?>>	DateOperation.getArgs()
<T> CaseForEqBuilder.Cases<T,Expression<T>>	CaseForEqBuilder.then(Expression<T> then)
<T> CaseForEqBuilder.Cases<T,Expression<T>>	CaseForEqBuilder.then(T then)
<T> CaseForEqBuilder.Cases<T,Expression<T>>	CaseForEqBuilder.thenNull()

Methods in com.mysema.query.types.expr with parameters of type Expression

Modifier and Type	Method and Description
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.acos(Expression<A> num)
<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
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.asin(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.atan(Expression<A> num)
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
Coalesce<T>	ComparableExpressionBase.coalesce(Expression<?>... exprs)
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 <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.cos(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.cosh(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.cot(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.coth(Expression<A> num)
static <D extends Enum<D>> EnumExpression<D>	EnumOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?>... args)
static <D extends Number & Comparable<?>> NumberExpression<D>	NumberOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?>... args)
static <D extends Enum<D>> EnumExpression<D>	EnumOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?> one)
static <D extends Number & Comparable<?>> NumberExpression<D>	NumberOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?> one)
static <D extends Enum<D>> EnumExpression<D>	EnumOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends Enum<D>> EnumExpression<D>	EnumOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends Number & Comparable<?>> NumberExpression<D>	NumberOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends Number & Comparable<?>> NumberExpression<D>	NumberOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D> DslExpression<D>	DslOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
static <D> SimpleExpression<D>	SimpleOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
static <D extends Comparable<?>> DateTimeExpression<D>	DateTimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
static <D extends Comparable<?>> TimeExpression<D>	TimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
static <D extends Comparable<?>> ComparableExpression<D>	ComparableOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
static <D extends Comparable<?>> DateExpression<D>	DateOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args)
static <D> DslExpression<D>	DslOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one)
static <D> SimpleExpression<D>	SimpleOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one)
static <D extends Comparable<?>> DateTimeExpression<D>	DateTimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one)
static <D extends Comparable<?>> TimeExpression<D>	TimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one)
static <D extends Comparable<?>> DateExpression<D>	DateOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one)
static <D> DslExpression<D>	DslOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D> DslExpression<D>	DslOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D> SimpleExpression<D>	SimpleOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D> SimpleExpression<D>	SimpleOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends Comparable<?>> DateTimeExpression<D>	DateTimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends Comparable<?>> DateTimeExpression<D>	DateTimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends Comparable<?>> TimeExpression<D>	TimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends Comparable<?>> TimeExpression<D>	TimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends Comparable<?>> DateExpression<D>	DateOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <D extends Comparable<?>> DateExpression<D>	DateOperation.create(Class<D> type, Operator<? super D> op, Expression<?> one, Expression<?> two)
static <E> CollectionOperation<E>	CollectionOperation.create(Operator<?> op, Class<E> type, Expression<?>... args)
static <E> CollectionOperation<E>	CollectionOperation.create(Operator<?> op, Class<E> type, Expression<?> one)
static <E> CollectionOperation<E>	CollectionOperation.create(Operator<?> op, Class<E> type, Expression<?> one, Expression<?> two)
static <E> CollectionOperation<E>	CollectionOperation.create(Operator<?> op, Class<E> type, Expression<?> one, Expression<?> two)
static BooleanExpression	BooleanOperation.create(Operator<? super Boolean> op, Expression<?>... args)
static BooleanExpression	BooleanOperation.create(Operator<? super Boolean> op, Expression<?> one)
static BooleanExpression	BooleanOperation.create(Operator<? super Boolean> op, Expression<?> one, Expression<?> two)
static BooleanExpression	BooleanOperation.create(Operator<? super Boolean> op, Expression<?> one, Expression<?> two)
static StringExpression	StringOperation.create(Operator<? super String> op, Expression<?>... args)
static StringExpression	StringOperation.create(Operator<? super String> op, Expression<?> one)
static StringExpression	StringOperation.create(Operator<? super String> op, Expression<?> one, Expression<?> two)
static StringExpression	StringOperation.create(Operator<? super String> op, Expression<?> one, Expression<?> two)
protected abstract Q	CaseBuilder.Cases.createResult(Class<A> type, Expression<A> last)
protected abstract Q	CaseForEqBuilder.Cases.createResult(Class<T> type, Expression<T> last)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.degrees(Expression<A> num)
<N extends Number & Comparable<?>> NumberExpression<T>	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 StringExpression to another StringExpression, ignoring case considerations.
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.exp(Expression<A> num)
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
BooleanExpression	NumberExpression.like(Expression<String> str) Expr: this like str
BooleanExpression	StringExpression.like(Expression<String> str) Expr: this like str
BooleanExpression	StringExpression.like(Expression<String> str, char escape) Expr: this like str
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.ln(Expression<A> num)
NumberExpression<Integer>	StringExpression.locate(Expression<String> str) Get the position of the given String in this String, the first position is 1
NumberExpression<Integer>	StringExpression.locate(Expression<String> str, NumberExpression<Integer> start) Get the position of the given String in this String, the first position is 1
<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
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.log(Expression<A> num, int base)
static StringExpression	StringExpressions.lpad(Expression<String> in, Expression<Integer> length)
static StringExpression	StringExpressions.lpad(Expression<String> in, Expression<Integer> length)
static StringExpression	StringExpressions.lpad(Expression<String> in, int length)
static StringExpression	StringExpressions.lpad(Expression<String> in, int length, char c)
static StringExpression	StringExpressions.lpad(Expression<String> in, NumberExpression<Integer> length, char c)
<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
static StringExpression	StringExpressions.ltrim(Expression<String> str)
BooleanExpression	StringExpression.matches(Expression<String> regex) Return true if this String matches the given regular expression
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.max(Expression<A> left, Expression<A> right) Return the greater of the given values
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.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.max(Expression<A> left, Expression<A> right) Return the greater of the given values
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.min(Expression<A> left, Expression<A> right) Return the smaller of the given values
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.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
static <A extends Number & Comparable<?>> NumberExpression<A>	NumberExpression.min(Expression<A> left, Expression<A> right) Return the smaller of the given values
NumberExpression<T>	NumberExpression.mod(Expression<T> num)
<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
BooleanExpression	StringExpression.notEqualsIgnoreCase(Expression<String> str) Compares this StringExpression to another StringExpression, ignoring case considerations.
BooleanExpression	StringExpression.notLike(Expression<String> str) Expr: this not like str
BooleanExpression	StringExpression.notLike(Expression<String> str, char escape) Expr: this not like str
SimpleExpression<T>	SimpleExpression.nullif(Expression<T> other) Get a nullif(this, other) expression
Q	CaseBuilder.Cases.otherwise(Expression<A> expr)
Q	CaseForEqBuilder.Cases.otherwise(Expression<T> otherwise)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.power(Expression<A> num, int exponent)
StringExpression	StringExpression.prepend(Expression<String> str) Prepend the given String and return the result
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.radians(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.round(Expression<A> num) Round to nearest integer
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.round(Expression<A> num, int s) Round to s decimal places
static StringExpression	StringExpressions.rpad(Expression<String> in, Expression<Integer> length)
static StringExpression	StringExpressions.rpad(Expression<String> in, Expression<Integer> length)
static StringExpression	StringExpressions.rpad(Expression<String> in, int length)
static StringExpression	StringExpressions.rpad(Expression<String> in, int length, char c)
static StringExpression	StringExpressions.rpad(Expression<String> in, NumberExpression<Integer> length, char c)
static StringExpression	StringExpressions.rtrim(Expression<String> str)
static <A extends Number & Comparable<?>> NumberExpression<Integer>	MathExpressions.sign(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.sin(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.sinh(Expression<A> num)
BooleanExpression	StringExpression.startsWith(Expression<String> str) Return true if this starts with str
BooleanExpression	StringExpression.startsWithIgnoreCase(Expression<String> str)
StringExpression	StringExpression.substring(Expression<Integer> beginIndex) Get the given substring
StringExpression	StringExpression.substring(Expression<Integer> beginIndex, Expression<Integer> endIndex) Get the given substring
StringExpression	StringExpression.substring(Expression<Integer> beginIndex, Expression<Integer> endIndex) Get the given substring
StringExpression	StringExpression.substring(Expression<Integer> beginIndex, int endIndex) Get the given substring
StringExpression	StringExpression.substring(int beginIndex, Expression<Integer> endIndex) Get the given substring
<N extends Number & Comparable<?>> NumberExpression<T>	NumberExpression.subtract(Expression<N> right) Get the difference of this and right
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.tan(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.tanh(Expression<A> num)
CaseBuilder.Cases<A,Q>	CaseBuilder.CaseWhen.then(Expression<A> expr)
<A> CaseBuilder.Cases<A,SimpleExpression<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

Constructor and Description
BooleanExpression(Expression<Boolean> mixin)
BooleanOperation(Operator<? super Boolean> op, Expression<?>... args)
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)
CollectionExpressionBase(Expression<T> mixin)
CollectionOperation(Operator<?> op, Class<? super E> type, Expression<?>... args)
ComparableExpression(Expression<T> mixin)
ComparableExpressionBase(Expression<T> mixin)
ComparableOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)
DateExpression(Expression<T> mixin)
DateOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)
DateTimeExpression(Expression<T> mixin)
DateTimeOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)
DslExpression(Expression<T> mixin)
DslOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)
EnumExpression(Expression<T> mixin)
EnumOperation(Class<? extends T> type, Operator<? super T> op, Expression<?>... args)
MapExpressionBase(Expression<Map<K,V>> mixin)
NumberExpression(Expression<T> mixin)
NumberOperation(Class<? extends T> type, Operator<? super T> op, Expression<?>... args)
SimpleExpression(Expression<T> mixin)
SimpleOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)
StringExpression(Expression<String> mixin)
StringOperation(Operator<? super String> op, Expression<?>... args)
TemporalExpression(Expression<T> mixin)
TimeExpression(Expression<T> mixin)
TimeOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)

Constructor parameters in com.mysema.query.types.expr with type arguments of type Expression

Constructor and Description
BooleanOperation(Operator<? super Boolean> op, com.google.common.collect.ImmutableList<Expression<?>> args)
CollectionOperation(Operator<?> op, Class<? super E> type, com.google.common.collect.ImmutableList<Expression<?>> args)
ComparableOperation(Class<T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)
DateOperation(Class<T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)
DateTimeOperation(Class<T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)
DslOperation(Class<T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)
EnumOperation(Class<? extends T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)
NumberOperation(Class<? extends T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)
SimpleOperation(Class<T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)
StringOperation(Operator<? super String> op, com.google.common.collect.ImmutableList<Expression<?>> args)
TimeOperation(Class<T> type, Operator<? super T> op, com.google.common.collect.ImmutableList<Expression<?>> args)

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

Classes in com.mysema.query.types.path that implement Expression

Modifier and Type	Class and Description
class	ArrayPath<A,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> ComparableEntityPath extends the ComparablePath class to implement the EntityPath interface
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	DslPath<T> DslPath represents simple 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

Modifier and Type	Method and Description
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

Modifier and Type	Interface and Description
interface	ExtendedSubQueryExpression<T> Extensions to the SubQueryExpression interface

Classes in com.mysema.query.types.query that implement Expression

Modifier and Type	Class and Description
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

Modifier and Type	Method and Description
SimpleExpression<?>	ListSubQuery.as(Expression<?> alias)

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

Classes in com.mysema.query.types.template that implement Expression

Modifier and Type	Class and Description
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	DslTemplate<T> DslTemplate defines custom simple 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