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.dml	DML interfaces
com.mysema.query.group
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<?>>	QueryMetadata.getGroupBy() Get the group by expressions
List<Expression<?>>	EmptyMetadata.getGroupBy()
List<Expression<?>>	DefaultQueryMetadata.getGroupBy()
List<Expression<?>>	QueryMetadata.getProjection() Get the projection
List<Expression<?>>	EmptyMetadata.getProjection()
List<Expression<?>>	DefaultQueryMetadata.getProjection()

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

Modifier and Type	Method and Description
void	QueryMetadata.addGroupBy(Expression<?> o) Add the given group by expressions
void	EmptyMetadata.addGroupBy(Expression<?> o)
void	DefaultQueryMetadata.addGroupBy(Expression<?> o)
void	QueryMetadata.addJoin(JoinType joinType, Expression<?> expr) Add the given query join
void	EmptyMetadata.addJoin(JoinType joinType, Expression<?> expr)
void	DefaultQueryMetadata.addJoin(JoinType joinType, Expression<?> expr)
void	QueryMetadata.addProjection(Expression<?> o) Add the given projections
void	EmptyMetadata.addProjection(Expression<?> o)
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 multi row subquery 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 multi row subquery 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 single row subquery expression for the given projection
<RT> SimpleSubQuery<RT>	Detachable.unique(Expression<RT> projection) Create a single row 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 resetting 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.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>
class	GSum<T extends Number>
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>	GroupExpression.getExpression()
Expression<T>	AbstractGroupExpression.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> 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.
<K,V> SortedMap<K,V>	Group.getSortedMap(Expression<K> key, Expression<V> value) Returns a SortedMap of values in this group
<K,V> SortedMap<K,V>	Group.getSortedMap(Expression<K> key, Expression<V> value) Returns a SortedMap of values in this group
<T> SortedSet<T>	Group.getSortedSet(Expression<T> expr) Returns a SortedSet 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 using a backing LinkedHashMap
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 using a backing LinkedHashMap
static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<K,U>>	GroupBy.map(Expression<K> key, GroupExpression<V,U> value) Create a new aggregating map expression using a backing LinkedHashMap
static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<T,V>>	GroupBy.map(GroupExpression<K,T> key, Expression<V> value) Create a new aggregating map expression using a backing LinkedHashMap
static <E extends Comparable<? super E>> AbstractGroupExpression<E,E>	GroupBy.max(Expression<E> expression) Create a new aggregating max expression
static <E extends Comparable<? super 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 using a backing LinkedHashSet
static <K extends Comparable<? super K>,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,V>>	GroupBy.sortedMap(Expression<K> key, Expression<V> value) Create a new aggregating map expression using a backing TreeMap
static <K extends Comparable<? super K>,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,V>>	GroupBy.sortedMap(Expression<K> key, Expression<V> value) Create a new aggregating map expression using a backing TreeMap
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,V>>	GroupBy.sortedMap(Expression<K> key, Expression<V> value, Comparator<? super K> comparator) Create a new aggregating map expression using a backing TreeMap using the given comparator
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,V>>	GroupBy.sortedMap(Expression<K> key, Expression<V> value, Comparator<? super K> comparator) Create a new aggregating map expression using a backing TreeMap using the given comparator
static <K extends Comparable<? super K>,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,U>>	GroupBy.sortedMap(Expression<K> key, GroupExpression<V,U> value) Create a new aggregating map expression using a backing TreeMap
static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<K,U>>	GroupBy.sortedMap(Expression<K> key, GroupExpression<V,U> value, Comparator<? super U> comparator) Create a new aggregating map expression using a backing TreeMap using the given comparator
static <K extends Comparable<? super K>,V,T extends Comparable<? super T>> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<T,V>>	GroupBy.sortedMap(GroupExpression<K,T> key, Expression<V> value) Create a new aggregating map expression using a backing TreeMap
static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,SortedMap<T,V>>	GroupBy.sortedMap(GroupExpression<K,T> key, Expression<V> value, Comparator<? super K> comparator) Create a new aggregating map expression using a backing TreeMap using the given comparator
static <E extends Comparable<? super E>> AbstractGroupExpression<E,SortedSet<E>>	GroupBy.sortedSet(Expression<E> expression) Create a new aggregating set expression using a backing TreeSet
static <E> AbstractGroupExpression<E,SortedSet<E>>	GroupBy.sortedSet(Expression<E> expression, Comparator<? super E> comparator) Create a new aggregating set expression using a backing TreeSet using the given comparator
static <E extends Number> 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.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<?>	CollectionAnyVisitor.visit(Constant<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(Constant<?> expr, Context context) Deprecated.
Expression<?>	ReplaceVisitor.visit(Constant<?> expr, Void context)
Expression<?>	CollectionAnyVisitor.visit(FactoryExpression<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(FactoryExpression<?> expr, Context context) Deprecated.
Expression<?>	ReplaceVisitor.visit(FactoryExpression<?> expr, Void context)
Expression<?>	CollectionAnyVisitor.visit(Operation<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(Operation<?> expr, Context context) Deprecated.
Expression<?>	ReplaceVisitor.visit(Operation<?> expr, Void context)
Expression<?>	CollectionAnyVisitor.visit(ParamExpression<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(ParamExpression<?> expr, Context context) Deprecated.
Expression<?>	ReplaceVisitor.visit(ParamExpression<?> expr, Void context)
Expression<?>	CollectionAnyVisitor.visit(Path<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(Path<?> expr, Context context) Deprecated.
Expression<?>	ReplaceVisitor.visit(Path<?> expr, Void context)
Expression<?>	CollectionAnyVisitor.visit(SubQueryExpression<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(SubQueryExpression<?> expr, Context context) Deprecated.
Expression<?>	ReplaceVisitor.visit(SubQueryExpression<?> expr, Void context)
Expression<?>	CollectionAnyVisitor.visit(TemplateExpression<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(TemplateExpression<?> expr, Context context) Deprecated.
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<?>>	EnumConversion.getArgs()
List<Expression<?>>	NumberConversion.getArgs()
List<Expression<?>>	NumberConversions.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)
Q	QueryBase.groupBy(Expression<?>... o) Add grouping/aggregation expressions
T	QueryMixin.groupBy(Expression<?>... o)
Q	QueryBase.groupBy(Expression<?> e) Add a single grouping expression
T	QueryMixin.groupBy(Expression<?> e)
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>	DetachableAdapter.list(Expression<?>... args)
ListSubQuery<Tuple>	DetachableQuery.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>	ProjectableAdapter.list(Expression<RT> projection)
<RT> List<RT>	ProjectableQuery.list(Expression<RT> projection)
<RT> ListSubQuery<RT>	DetachableMixin.list(Expression<RT> projection)
<RT> ListSubQuery<RT>	DetachableAdapter.list(Expression<RT> projection)
<RT> ListSubQuery<RT>	DetachableQuery.list(Expression<RT> projection)
SearchResults<Tuple>	ProjectableAdapter.listResults(Expression<?>... args)
<RT> SearchResults<RT>	ProjectableAdapter.listResults(Expression<RT> expr)
<K,V> Map<K,V>	ProjectableAdapter.map(Expression<K> key, Expression<V> value)
<K,V> Map<K,V>	ProjectableAdapter.map(Expression<K> key, Expression<V> value)
<K,V> Map<K,V>	ProjectableQuery.map(Expression<K> key, Expression<V> value)
<K,V> Map<K,V>	ProjectableQuery.map(Expression<K> key, Expression<V> value)
static <T extends Number & Comparable<?>> NumberExpression<T>	Expressions.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	ProjectableAdapter.singleResult(Expression<?>... args)
Tuple	ProjectableQuery.singleResult(Expression<?>... args)
<RT> RT	ProjectableAdapter.singleResult(Expression<RT> expr)
<RT> RT	ProjectableQuery.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>	DetachableAdapter.unique(Expression<?>... args)
SimpleSubQuery<Tuple>	DetachableQuery.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>	DetachableAdapter.unique(Expression<RT> projection)
<RT> SimpleSubQuery<RT>	DetachableQuery.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	ParametrizedPathImpl<T> ParametrizedPathImpl represents Path instances with a parameterized generic type
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<?>	ExpressionUtils.orderBy(List<OrderSpecifier<?>> args) Create an expression out of the given order specifiers
static Expression<String>	ExpressionUtils.regexToLike(Expression<String> expr)
static Expression<?>	ExpressionUtils.toExpression(Object o) Converts the given object to an Expression
static Expression<String>	ExpressionUtils.toLower(Expression<String> stringExpression) Converts the given expression to lower(expression)

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<?>>	QTuple.getArgs()
List<Expression<?>>	MappingProjection.getArgs()
List<Expression<?>>	ArrayConstructorExpression.getArgs()
List<Expression<?>>	ConstructorExpression.getArgs()
List<Expression<?>>	QList.getArgs()
List<Expression<?>>	QBean.getArgs()
List<Expression<?>>	Operation.getArgs() Get the arguments of this operation
List<Expression<?>>	OperationImpl.getArgs()
List<Expression<?>>	QMap.getArgs()
List<Expression<?>>	FactoryExpression.getArgs() Get the invocation arguments
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 <D> Predicate	ExpressionUtils.inAny(Expression<D> left, Iterable<? extends Collection<? extends D>> lists) Create a left in right or... expression for each list
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
static <D> Predicate	ExpressionUtils.notIn(Expression<D> left, Collection<? extends D> right) Create an left not in right expression
static <D> Predicate	ExpressionUtils.notIn(Expression<D> left, CollectionExpression<?,? extends D> right) Create an left not in right expression
static <D> Predicate	ExpressionUtils.notInAny(Expression<D> left, Iterable<? extends Collection<? extends D>> lists) Create a left not in right and... expression for each list
static <T> Operation<T>	ExpressionUtils.operation(Class<? extends T> type, Operator<T> operator, Expression<?>... args) Create a new Operation expression
static PredicateOperation	ExpressionUtils.predicate(Operator<Boolean> operator, Expression<?>... args) Create a new Operation expression
protected void	QBean.propertyNotFound(Expression<?> expr, String property)
static Expression<String>	ExpressionUtils.regexToLike(Expression<String> expr)
static Expression<String>	ExpressionUtils.toLower(Expression<String> stringExpression) Converts the given expression to lower(expression)
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)
static <T> Operation<T>	ExpressionUtils.operation(Class<? extends T> type, Operator<T> operator, com.google.common.collect.ImmutableList<Expression<?>> args) Create a new Operation expression
static PredicateOperation	ExpressionUtils.predicate(Operator<Boolean> operator, com.google.common.collect.ImmutableList<Expression<?>> args) Create a new Operation expression
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 Wildcard 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<?>	StringOperation.getArg(int index)
Expression<?>	BooleanOperation.getArg(int index)
Expression<?>	TimeOperation.getArg(int index)
Expression<?>	DslOperation.getArg(int index)
Expression<?>	ComparableOperation.getArg(int index)
Expression<?>	DateOperation.getArg(int index)
Expression<?>	EnumOperation.getArg(int index)
Expression<?>	DateTimeOperation.getArg(int index)
Expression<?>	SimpleOperation.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<?>>	StringOperation.getArgs()
List<Expression<?>>	BooleanOperation.getArgs()
List<Expression<?>>	TimeOperation.getArgs()
List<Expression<?>>	DslOperation.getArgs()
List<Expression<?>>	ComparableOperation.getArgs()
List<Expression<?>>	DateOperation.getArgs()
List<Expression<?>>	EnumOperation.getArgs()
List<Expression<?>>	DateTimeOperation.getArgs()
List<Expression<?>>	SimpleOperation.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 from <= this <= to expression
BooleanExpression	ComparableExpression.between(Expression<T> from, Expression<T> to) Get a from <= this <= to 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<?>> 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 extends Comparable<?>> DateTimeExpression<D>	DateTimeOperation.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<?>> 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 extends Comparable<?>> DateTimeExpression<D>	DateTimeOperation.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<?>> 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 <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 <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
BooleanExpression	StringExpression.likeIgnoreCase(Expression<String> str) Expr: this like str ignoring case.
BooleanExpression	StringExpression.likeIgnoreCase(Expression<String> str, char escape) Expr: this like str ignoring case
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>	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.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.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>	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
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(Expression<D> base, Expression<? extends D> other)
CaseForEqBuilder(Expression<D> base, Expression<? extends D> other)
CaseWhen(CaseForEqBuilder.Cases<T,Q> cases, Expression<? extends D> when)
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