Uses of Interface
com.querydsl.core.types.Expression

Packages that use Expression

Package	Description
com.querydsl.core	Basic Query elements
com.querydsl.core.alias	Alias functionality
com.querydsl.core.dml	DML interfaces
com.querydsl.core.group	Aggregating post processing functionality
com.querydsl.core.support	Various support classes
com.querydsl.core.types	Expression types
com.querydsl.core.types.dsl	DSL expression types

Uses of Expression in com.querydsl.core

Classes in com.querydsl.core that implement Expression

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

Methods in com.querydsl.core that return Expression

Modifier and Type	Method and Description
Expression<?>	QueryFlag.getFlag()
Expression<?>	JoinFlag.getFlag()
Expression<?>	QueryMetadata.getProjection() Get the projection
Expression<?>	EmptyMetadata.getProjection()
Expression<?>	DefaultQueryMetadata.getProjection()
Expression<?>	JoinExpression.getTarget()

Methods in com.querydsl.core 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()

Methods in com.querydsl.core 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)
<T> T	Tuple.get(Expression<T> expr) Get a tuple element by expression
Q	Query.groupBy(Expression<?>... o) Add grouping/aggregation expressions
FetchableQuery<Tuple,?>	FetchableQuery.select(Expression<?>... exprs) Change the projection of this query
<U> FetchableQuery<U,?>	FetchableQuery.select(Expression<U> expr) Change the projection of this query
void	QueryMetadata.setProjection(Expression<?> o) Set the projection
void	EmptyMetadata.setProjection(Expression<?> o)
void	DefaultQueryMetadata.setProjection(Expression<?> o)

Constructors in com.querydsl.core 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) Create a new instance using the given flag
JoinFlag(Expression<?> flag, JoinFlag.Position position) Create a new instance using the given flag and position
QueryFlag(QueryFlag.Position position, Expression<?> flag)

Uses of Expression in com.querydsl.core.alias

Methods in com.querydsl.core.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

Methods in com.querydsl.core.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.querydsl.core.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

Uses of Expression in com.querydsl.core.dml

Methods in com.querydsl.core.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.querydsl.core.group

Subinterfaces of Expression in com.querydsl.core.group

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

Classes in com.querydsl.core.group that implement Expression

Modifier and Type	Class and Description
class	AbstractGroupExpression<T,R> A base class for GroupExpressions
class	MixinGroupExpression<E,F,R> MixinGroupExpression provides nesting support for GroupExpression instances
class	QPair<K,V> A pair of (Map) key and value

Methods in com.querydsl.core.group that return Expression

Modifier and Type	Method and Description
Expression<T>	GroupExpression.getExpression() Get the expression wrapped by this group definition
Expression<T>	AbstractGroupExpression.getExpression()

Methods in com.querydsl.core.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 K> comparator) Create a new aggregating map expression using a backing TreeMap using the given comparator
static <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 T> 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.querydsl.core.group with parameters of type Expression

Constructor and Description
AbstractGroupExpression(Class<? super R> type, 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)
QPair(Expression<K> key, Expression<V> value)
QPair(Expression<K> key, Expression<V> value)

Uses of Expression in com.querydsl.core.support

Subinterfaces of Expression in com.querydsl.core.support

Modifier and Type	Interface and Description
interface	ExtendedSubQuery<T> ExtendedSubQuery extends the SubQueryExpression interface to provide fluent expression creation functionality

Classes in com.querydsl.core.support that implement Expression

Modifier and Type	Class and Description
class	ConstantHidingExpression<T> ConstantHidingExpression removes constants from the argument list and injects them back into the result chain
class	EnumConversion<T> EnumConversion ensures that the results of an enum projection conform to the type of the projection expression
class	FetchableSubQueryBase<T,Q extends FetchableSubQueryBase<T,Q>> FetchableSubQueryBase extends FetchableQueryBase to provide fluent Expression creation functionality
class	NumberConversion<T> NumberConversion ensures that the results of a numeric projection conform to the type of the projection expression
class	NumberConversions<T> NumberConversions ensures that the results of a projection involving numeric expressions conform to the types of the numeric expressions

Methods in com.querydsl.core.support that return Expression

Modifier and Type	Method and Description
<RT> Expression<RT>	QueryMixin.convert(Expression<RT> expr, QueryMixin.Role role)
protected <D> Expression<D>	QueryMixin.createAlias(Expression<?> expr, Path<D> alias)
Expression<?>	QueryMixin.setProjection(Expression<?>... o)
<E> Expression<E>	QueryMixin.setProjection(Expression<E> e)
Expression<?>	ReplaceVisitor.visit(Constant<?> expr, C context)
Expression<?>	CollectionAnyVisitor.visit(Constant<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(FactoryExpression<?> expr, C context)
Expression<?>	CollectionAnyVisitor.visit(FactoryExpression<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(Operation<?> expr, C context)
Expression<?>	CollectionAnyVisitor.visit(Operation<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(ParamExpression<?> expr, C context)
Expression<?>	CollectionAnyVisitor.visit(ParamExpression<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(Path<?> expr, C context)
Expression<?>	CollectionAnyVisitor.visit(Path<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(SubQueryExpression<?> expr, C context)
Expression<?>	CollectionAnyVisitor.visit(SubQueryExpression<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(TemplateExpression<?> expr, C context)
Expression<?>	CollectionAnyVisitor.visit(TemplateExpression<?> expr, Context context)

Methods in com.querydsl.core.support that return types with arguments of type Expression

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

Methods in com.querydsl.core.support with parameters of type Expression

Modifier and Type	Method and Description
T	QueryMixin.addJoin(JoinType joinType, Expression<?> target)
void	OrderedQueryMetadata.addJoin(JoinType joinType, Expression<?> expr)
BooleanExpression	FetchableSubQueryBase.contains(Expression<? extends T> right)
BooleanExpression	ExtendedSubQuery.contains(Expression<? extends T> right) Create a right in this expression
<RT> Expression<RT>	QueryMixin.convert(Expression<RT> expr, QueryMixin.Role role)
protected <D> Expression<D>	QueryMixin.createAlias(Expression<?> expr, Path<D> alias)
BooleanExpression	FetchableSubQueryBase.eq(Expression<? extends T> expr)
BooleanExpression	ExtendedSubQuery.eq(Expression<? extends T> expr) Create a this == right 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)
BooleanExpression	FetchableSubQueryBase.goe(Expression<? extends T> expr)
BooleanExpression	ExtendedSubQuery.goe(Expression<? extends T> expr) Create a this >= right expression
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
BooleanExpression	FetchableSubQueryBase.gt(Expression<? extends T> expr)
BooleanExpression	ExtendedSubQuery.gt(Expression<? extends T> expr) Create a this > right 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)
<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)
BooleanExpression	FetchableSubQueryBase.loe(Expression<? extends T> expr)
BooleanExpression	ExtendedSubQuery.loe(Expression<? extends T> expr) Create a this <= right expression
BooleanExpression	FetchableSubQueryBase.lt(Expression<? extends T> expr)
BooleanExpression	ExtendedSubQuery.lt(Expression<? extends T> expr) Create a this < right expression
BooleanExpression	FetchableSubQueryBase.ne(Expression<? extends T> expr)
BooleanExpression	ExtendedSubQuery.ne(Expression<? extends T> expr) Create a this != right expression
<P> T	QueryMixin.rightJoin(Expression<P> target)
<P> T	QueryMixin.rightJoin(Expression<P> target, Path<P> alias)
Expression<?>	QueryMixin.setProjection(Expression<?>... o)
<E> Expression<E>	QueryMixin.setProjection(Expression<E> e)

Method parameters in com.querydsl.core.support with type arguments of type Expression

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

Constructors in com.querydsl.core.support with parameters of type Expression

Constructor and Description
EnumConversion(Expression<T> expr)
NumberConversion(Expression<T> expr)

Uses of Expression in com.querydsl.core.types

Subinterfaces of Expression in com.querydsl.core.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	ParameterizedExpression<T> ParameterizedExpression 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.querydsl.core.types that implement Expression

Modifier and Type	Class and Description
class	ArrayConstructorExpression<T> ArrayConstructorExpression extends FactoryExpressionBase 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> FactoryExpressionAdapter provides an adapter implementation of the FactoryExpression interface
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	ParameterizedPathImpl<T> ParameterizedPathImpl 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.querydsl.core.types that return Expression

Modifier and Type	Method and Description
static <T> Expression<T>	ExpressionUtils.all(CollectionExpression<?,? super T> col) Create a all col expression
static <T> Expression<T>	ExpressionUtils.all(SubQueryExpression<? extends T> col) Create a all col expression
static <T> Expression<T>	ExpressionUtils.any(CollectionExpression<?,? super T> col) Create a any col expression
static <T> Expression<T>	ExpressionUtils.any(SubQueryExpression<? extends T> col) Create a any col expression
static <D> Expression<D>	ExpressionUtils.as(Expression<D> source, Path<D> alias) Create an alias expression with the given source and alias
static <D> Expression<D>	ExpressionUtils.as(Expression<D> source, String alias) Create an alias expression with the given source and alias
Expression<T>	QBean.as(Path<T> alias) Create an alias for the expression
Expression<T>	ConstructorExpression.as(Path<T> alias) Create an alias for the expression
Expression<T>	QBean.as(String alias) Create an alias for the expression
Expression<T>	ConstructorExpression.as(String alias) Create an alias for the expression
static Expression<Long>	ExpressionUtils.count(Expression<?> source) Create a count(source) expression
static <T> Expression<T>	ExpressionUtils.extract(Expression<T> expr) Get the potentially wrapped expression
Expression<?>	OperationImpl.getArg(int i)
Expression<?>	Operation.getArg(int index) Get the argument with the given index
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) Convert the given like pattern to a regex pattern
static <T> Expression<T>	ExpressionUtils.list(Class<T> clazz, Expression<?>... exprs) Create a list expression for the given arguments
static <T> Expression<T>	ExpressionUtils.list(Class<T> clazz, List<? extends Expression<?>> exprs) Create a list expression for the given arguments
static Expression<?>	ExpressionUtils.orderBy(List<OrderSpecifier<?>> args) Create an expression out of the given order specifiers
static Expression<String>	ExpressionUtils.regexToLike(Expression<String> expr) Convert the given expression from regex form to like
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.querydsl.core.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) Create a distinct list of the given args
static com.google.common.collect.ImmutableList<Expression<?>>	ExpressionUtils.distinctList(Expression<?>[]... args) Create a distinct list of the concatenated array contents
List<Expression<?>>	QTuple.getArgs()
List<Expression<?>>	QMap.getArgs()
List<Expression<?>>	QList.getArgs()
List<Expression<?>>	QBean.getArgs()
List<Expression<?>>	OperationImpl.getArgs()
List<Expression<?>>	Operation.getArgs() Get the arguments of this operation
List<Expression<?>>	MappingProjection.getArgs()
List<Expression<?>>	FactoryExpressionUtils.FactoryExpressionAdapter.getArgs()
List<Expression<?>>	FactoryExpression.getArgs() Get the invocation arguments
List<Expression<?>>	ConstructorExpression.getArgs()
List<Expression<?>>	ArrayConstructorExpression.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.querydsl.core.types with parameters of type Expression

Modifier and Type	Method and Description
static <T> com.querydsl.core.types.AppendingFactoryExpression<T>	Projections.appending(Expression<T> base, Expression<?>... rest) Create an appending factory expression which serializes all the arguments but the uses the base value as the return value
static <T> com.querydsl.core.types.AppendingFactoryExpression<T>	Projections.appending(Expression<T> base, Expression<?>... rest) Create an appending factory expression which serializes all the arguments but the uses the base value as the return value
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 with the given source and alias
static <D> Expression<D>	ExpressionUtils.as(Expression<D> source, String alias) Create an alias expression with the given source and alias
static <T> QBean<T>	Projections.bean(Class<? extends T> type, Expression<?>... exprs) Create a Bean populating projection for the given type and expressions
static <T> QBean<T>	Projections.bean(Path<? extends T> type, Expression<?>... exprs) Create a Bean populating projection for the given type and expressions
static <T> ConstructorExpression<T>	Projections.constructor(Class<? extends T> type, Class<?>[] paramTypes, Expression<?>... exprs) Create a constructor invocation projection for given type, parameter types and expressions
static <T> ConstructorExpression<T>	Projections.constructor(Class<? extends T> type, Expression<?>... exprs) Create a constructor invocation projection for the given type and expressions
static Expression<Long>	ExpressionUtils.count(Expression<?> source) Create a count(source) expression
static com.google.common.collect.ImmutableList<Expression<?>>	ExpressionUtils.distinctList(Expression<?>... args) Create a distinct list of the given args
static com.google.common.collect.ImmutableList<Expression<?>>	ExpressionUtils.distinctList(Expression<?>[]... args) Create a distinct list of the concatenated array contents
static <D> Predicate	ExpressionUtils.eq(Expression<D> left, Expression<? extends D> right) Create a left == right expression
static <D> Predicate	ExpressionUtils.eq(Expression<D> left, Expression<? extends D> right) Create a left == right expression
static <D> Predicate	ExpressionUtils.eqConst(Expression<D> left, D constant) Create a left == constant expression
static <T> Expression<T>	ExpressionUtils.extract(Expression<T> expr) Get the potentially wrapped expression
static <T> QBean<T>	Projections.fields(Class<? extends 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<? extends T> type, Expression<?>... exprs) Create a field access based Bean populating projection for the given type and expressions
static PathMetadata	PathMetadataFactory.forArrayAccess(Path<?> parent, Expression<Integer> index) Create a new PathMetadata instance for indexed array access
static PathMetadata	PathMetadataFactory.forListAccess(Path<?> parent, Expression<Integer> index) Create a new PathMetadata instance for indexed list access
static <KT> PathMetadata	PathMetadataFactory.forMapAccess(Path<?> parent, Expression<KT> key) Create a new PathMetadata instance for key based map access
static <D> Predicate	ExpressionUtils.in(Expression<D> left, Collection<? extends D> right) Create a left in right expression
static <D> Predicate	ExpressionUtils.in(Expression<D> left, CollectionExpression<?,? extends D> right) Create a left in right expression
static <D> Predicate	ExpressionUtils.in(Expression<D> left, SubQueryExpression<? extends D> right) Create a 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) Convert the given like pattern to a regex pattern
static <T> Expression<T>	ExpressionUtils.list(Class<T> clazz, Expression<?>... exprs) Create a list expression for the given arguments
static QList	Projections.list(Expression<?>... args) Create a new List typed projection for the given expressions
static QList	Projections.list(Expression<?>[]... args) Create a new List typed projection for the given expressions
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 != right expression
static <D> Predicate	ExpressionUtils.ne(Expression<D> left, Expression<? super D> right) Create a left != right expression
static <D> Predicate	ExpressionUtils.neConst(Expression<D> left, D constant) Create a left != constant expression
static <D> Predicate	ExpressionUtils.notIn(Expression<D> left, Collection<? extends D> right) Create a left not in right expression
static <D> Predicate	ExpressionUtils.notIn(Expression<D> left, CollectionExpression<?,? extends D> right) Create a left not in right expression
static <D> Predicate	ExpressionUtils.notIn(Expression<D> left, SubQueryExpression<? extends D> right) Create a 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 operator, Expression<?>... args) Create a new Operation expression
static PredicateOperation	ExpressionUtils.predicate(Operator operator, Expression<?>... args) Create a new Operation expression
protected void	QBean.propertyNotFound(Expression<?> expr, String property)
static Expression<String>	ExpressionUtils.regexToLike(Expression<String> expr) Convert the given expression from regex form to like
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
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.querydsl.core.types with type arguments of type Expression

Modifier and Type	Method and Description
static <T> QBean<T>	Projections.bean(Class<? extends T> type, Map<String,? extends Expression<?>> bindings) Create a Bean populating projection for the given type and bindings
static <T> QBean<T>	Projections.bean(Path<? extends T> type, Map<String,? extends Expression<?>> bindings) Create a Bean populating projection for the given type and bindings
static <T> ConstructorExpression<T>	Projections.constructor(Class<? extends T> type, Class<?>[] paramTypes, com.google.common.collect.ImmutableList<Expression<?>> exprs) Create a constructor invocation projection for given type, parameter types and expressions
static <T> QBean<T>	Projections.fields(Class<? extends T> type, Map<String,? extends Expression<?>> bindings) Create a field access based Bean populating projection for the given type and bindings
static <T> QBean<T>	Projections.fields(Path<? extends T> type, Map<String,? extends Expression<?>> bindings) Create a field access based Bean populating projection for the given type and bindings
static <T> Expression<T>	ExpressionUtils.list(Class<T> clazz, List<? extends Expression<?>> exprs) Create a list expression for the given arguments
static QList	Projections.list(com.google.common.collect.ImmutableList<Expression<?>> args) Create a new List typed projection for the given expressions
static <T> Operation<T>	ExpressionUtils.operation(Class<? extends T> type, Operator operator, com.google.common.collect.ImmutableList<Expression<?>> args) Create a new Operation expression
static PredicateOperation	ExpressionUtils.predicate(Operator operator, com.google.common.collect.ImmutableList<Expression<?>> args) Create a new Operation expression
static QTuple	Projections.tuple(com.google.common.collect.ImmutableList<Expression<?>> exprs) Create a Tuple typed projection for the given expressions
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.querydsl.core.types with parameters of type Expression

Constructor and Description
ArrayConstructorExpression(Class<T[]> type, Expression<T>... args)
ArrayConstructorExpression(Expression<?>... args)
ConstructorExpression(Class<? extends T> type, Class<?>[] paramTypes, Expression<?>... args)
ConstructorExpression(Class<? extends T> type, 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 operator, Expression<?>... args)
OrderSpecifier(Order order, Expression<T> target)
OrderSpecifier(Order order, Expression<T> target, OrderSpecifier.NullHandling nullhandling)
QBean(Class<? extends T> type, boolean fieldAccess, Expression<?>... args) Create a new QBean instance
QBean(Class<? extends 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.querydsl.core.types with type arguments of type Expression

Constructor and Description
ConstructorExpression(Class<? extends T> type, Class<?>[] paramTypes, com.google.common.collect.ImmutableList<Expression<?>> args)
OperationImpl(Class<? extends T> type, Operator operator, com.google.common.collect.ImmutableList<Expression<?>> args)
PredicateOperation(Operator operator, com.google.common.collect.ImmutableList<Expression<?>> args)
QBean(Class<? extends T> type, boolean fieldAccess, Map<String,? extends Expression<?>> bindings) Create a new QBean instance
QBean(Class<? extends 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.querydsl.core.types.dsl

Classes in com.querydsl.core.types.dsl 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>> Intermediate step
class	CaseForEqBuilder.CaseWhen<T,Q extends Expression<T>> Intermediate step

Subinterfaces of Expression in com.querydsl.core.types.dsl

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.querydsl.core.types.dsl 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	BooleanExpression BooleanExpression represents Boolean expressions
class	BooleanOperation BooleanOperation represents boolean operations
class	BooleanPath BooleanPath represents boolean path expressions
class	BooleanTemplate BooleanTemplate is a custom boolean expression
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> CollectionOperation is a collection typed operation
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	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	ComparablePath<T extends Comparable> ComparablePath represents comparable paths
class	ComparableTemplate<T extends Comparable<?>> ComparableTemplate defines custom comparable expressions
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	DatePath<T extends Comparable> DatePath presents Date paths
class	DateTemplate<T extends Comparable<?>> DateTemplate defines custom date expressions
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	DateTimePath<T extends Comparable> DateTimePath presents DateTime typed paths
class	DateTimeTemplate<T extends Comparable<?>> DateTimeTemplate defines custom dateTime expressions
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	DslPath<T> DslPath represents simple paths
class	DslTemplate<T> DslTemplate defines custom simple expressions
class	EntityPathBase<T> EntityPathBase provides a base class for EntityPath implementations
class	EnumExpression<T extends Enum<T>> EnumExpression represents Enum typed expressions
class	EnumOperation<T extends Enum<T>> EnumOperation represents enum operations
class	EnumPath<T extends Enum<T>> EnumPath represents enum paths
class	EnumTemplate<T extends Enum<T>> EnumTemplate defines custom enum expressions
class	ListPath<E,Q extends SimpleExpression<? super E>> ListPath represents list paths
class	LiteralExpression<T extends Comparable> LiteralExpression represents literal expressions
class	MapExpressionBase<K,V,Q extends SimpleExpression<? super V>> MapExpressionBase is an abstract base class for MapExpression implementations
class	MapPath<K,V,E extends SimpleExpression<? super V>> MapPath represents map paths
class	NumberExpression<T extends Number & Comparable<?>> NumberExpression represents a numeric expression
class	NumberOperation<T extends Number & Comparable<?>> NumberOperation represents numeric operations
class	NumberPath<T extends Number & Comparable<?>> NumberPath represents numeric paths
class	NumberTemplate<T extends Number & Comparable<?>> NumberTemplate defines custom numeric expressions
class	Param<T> Param defines a parameter in a query with an optional name
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	SimpleExpression<T> SimpleExpression is the base class for Expression implementations.
class	SimpleOperation<T> SimpleOperation represents a simple operation expression
class	SimplePath<T> SimplePath represents simple paths
class	SimpleTemplate<T> SimpleTemplate defines custom simple expressions
class	StringExpression StringExpression represents String expressions
class	StringOperation StringOperation represents a String typed operation
class	StringPath StringPath represents String typed paths
class	StringTemplate StringTemplate defines custom String expressions
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
class	TimePath<T extends Comparable> TimePath represented Time paths
class	TimeTemplate<T extends Comparable<?>> TimeTemplate defines custom time expressions

Fields in com.querydsl.core.types.dsl 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.querydsl.core.types.dsl that return Expression

Modifier and Type	Method and Description
static <T> Expression<T>	Expressions.constant(T value) Create a Constant expression for the given value
Expression<?>	TimeOperation.getArg(int index)
Expression<?>	StringOperation.getArg(int index)
Expression<?>	SimpleOperation.getArg(int index)
Expression<?>	NumberOperation.getArg(int index)
Expression<?>	EnumOperation.getArg(int index)
Expression<?>	DslOperation.getArg(int index)
Expression<?>	DateTimeOperation.getArg(int index)
Expression<?>	DateOperation.getArg(int index)
Expression<?>	ComparableOperation.getArg(int index)
Expression<?>	BooleanOperation.getArg(int index)
static <T> Expression<T>	Expressions.list(Class<T> clazz, Expression<?>... exprs) Combine the given expressions into a list expression
static Expression<Tuple>	Expressions.list(Expression<?>... exprs) Combine the given expressions into a list expression

Methods in com.querydsl.core.types.dsl that return types with arguments of type Expression

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

Methods in com.querydsl.core.types.dsl with parameters of type Expression

Modifier and Type	Method and Description
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.acos(Expression<A> num) Create a acos(num) expression
<N extends Number & Comparable<?>> NumberExpression<T>	NumberExpression.add(Expression<N> right) Create a this + right expression
Coalesce<T>	Coalesce.add(Expression<T> expr)
BooleanExpression	TemporalExpression.after(Expression<T> right) Create a this > right expression
StringExpression	StringExpression.append(Expression<String> str) Create a concat(this, str) expression
static <D> SimpleExpression<D>	Expressions.as(Expression<D> source, Path<D> alias) Create a source as alias expression
static <D> SimpleExpression<D>	Expressions.as(Expression<D> source, String alias) Create a source as alias expression
static BooleanExpression	Expressions.asBoolean(Expression<Boolean> expr) Create a new BooleanExpression
static <T extends Comparable<?>> ComparableExpression<T>	Expressions.asComparable(Expression<T> expr) Create a new ComparableExpression
static <T extends Comparable<?>> DateExpression<T>	Expressions.asDate(Expression<T> expr) Create a new DateExpression
static <T extends Comparable<?>> DateTimeExpression<T>	Expressions.asDateTime(Expression<T> expr) Create a new DateTimeExpression
static <T extends Enum<T>> EnumExpression<T>	Expressions.asEnum(Expression<T> expr) Create a new EnumExpression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.asin(Expression<A> num) Create a asin(num) expression
static <T extends Number & Comparable<?>> NumberExpression<T>	Expressions.asNumber(Expression<T> expr) Create a new NumberExpression
static <T> SimpleExpression<T>	Expressions.asSimple(Expression<T> expr) Create a new SimpleExpression
static StringExpression	Expressions.asString(Expression<String> expr) Create a new StringExpression
static <T extends Comparable<?>> TimeExpression<T>	Expressions.asTime(Expression<T> expr) Create a new TimeExpression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.atan(Expression<A> num) Create a atan(num) expression
BooleanExpression	TemporalExpression.before(Expression<T> right) Create a this < right expression
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.between(Expression<A> from, Expression<A> to) Create a this between from and to expression
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.between(Expression<A> from, Expression<A> to) Create a this between from and to expression
BooleanExpression	ComparableExpression.between(Expression<T> from, Expression<T> to) Create a this between from and to expression
BooleanExpression	ComparableExpression.between(Expression<T> from, Expression<T> to) Create a this between from and to expression
static BooleanOperation	Expressions.booleanOperation(Operator operator, Expression<?>... args) Create a new Boolean operation
SimpleExpression<Character>	StringExpression.charAt(Expression<Integer> i) Create a this.charAt(i) expression
Coalesce<T>	ComparableExpressionBase.coalesce(Expression<?>... exprs) Create a coalesce(this, exprs...) expression
static <T> CollectionExpression<Collection<T>,T>	Expressions.collectionOperation(Class<T> elementType, Operator operator, Expression<?>... args) Create a new Collection operation expression
static <T extends Comparable<?>> ComparableOperation<T>	Expressions.comparableOperation(Class<? extends T> type, Operator operator, Expression<?>... args) Create a new Operation expression
StringExpression	StringExpression.concat(Expression<String> str) Create a concat(this, str) expression
BooleanExpression	CollectionExpressionBase.contains(Expression<E> child) Create a this.contains(child) expression
BooleanExpression	MapExpressionBase.contains(Expression<K> key, Expression<V> value) Create a (key, value) in this expression
BooleanExpression	MapExpressionBase.contains(Expression<K> key, Expression<V> value) Create a (key, value) in this expression
BooleanExpression	StringExpression.contains(Expression<String> str) Create a this.contains(str) expression
BooleanExpression	StringExpression.containsIgnoreCase(Expression<String> str) Create a this.containsIgnoreCase(str) expression
BooleanExpression	MapExpressionBase.containsKey(Expression<K> key) Create a key in keys(this) expression
BooleanExpression	MapExpressionBase.containsValue(Expression<V> value) Create a value in values(this) expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.cos(Expression<A> num) Create a cos(num) expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.cosh(Expression<A> num) Create a cosh(num) expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.cot(Expression<A> num) Create a cot(num) expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.coth(Expression<A> num) Create a coth(num) expression
protected abstract Q	CaseBuilder.Cases.createResult(Class<? extends A> type, Expression<A> last)
protected abstract Q	CaseForEqBuilder.Cases.createResult(Class<T> type, Expression<T> last)
static <T extends Comparable<?>> DateOperation<T>	Expressions.dateOperation(Class<? extends T> type, Operator operator, Expression<?>... args) Create a new Operation expression
static <T extends Comparable<?>> DateTimeOperation<T>	Expressions.dateTimeOperation(Class<? extends T> type, Operator operator, Expression<?>... args) Create a new Operation expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.degrees(Expression<A> num) Create a deg(num) expression
<N extends Number & Comparable<?>> NumberExpression<T>	NumberExpression.divide(Expression<N> right) Create a this / right expression
static <T> DslOperation<T>	Expressions.dslOperation(Class<? extends T> type, Operator operator, Expression<?>... args) Create a new Operation expression
BooleanExpression	StringExpression.endsWith(Expression<String> str) Create a this.endsWith(str) expression
BooleanExpression	StringExpression.endsWithIgnoreCase(Expression<String> str) Create a this.endsWithIgnoreCase(str) expression
static <T extends Enum<T>> EnumOperation<T>	Expressions.enumOperation(Class<? extends T> type, Operator operator, Expression<?>... args) Create a new Enum operation expression
BooleanExpression	SimpleExpression.eq(Expression<? super T> right) Create a this == right expression
BooleanExpression	StringExpression.equalsIgnoreCase(Expression<String> str) Create a this.equalsIgnoreCase(str) expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.exp(Expression<A> num) Create a exp(num) expression
protected PathMetadata	ListPath.forListAccess(Expression<Integer> index)
protected PathMetadata	MapPath.forMapAccess(Expression<K> key)
Q	ListPath.get(Expression<Integer> index)
Q	ListExpression.get(Expression<Integer> index) Indexed access, gets the element at the given index
SimplePath<E>	ArrayPath.get(Expression<Integer> index)
SimpleExpression<T>	ArrayExpression.get(Expression<Integer> index) Create a this[index] expression
E	MapPath.get(Expression<K> key)
abstract Q	MapExpressionBase.get(Expression<K> key) Create a this.get(key) expression
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.goe(Expression<A> right) Create a this >= right expression
BooleanExpression	ComparableExpression.goe(Expression<T> right) Create 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) Create a this > right expression
BooleanExpression	SimpleExpression.in(Expression<? extends T>... right) Create a this in right expression
NumberExpression<Integer>	StringExpression.indexOf(Expression<String> str) Create a this.indexOf(str) expression
NumberExpression<Integer>	StringExpression.indexOf(Expression<String> str, int i) Create a this.indexOf(str) expression
BooleanExpression	StringExpression.like(Expression<String> str) Create a this like str expression
BooleanExpression	NumberExpression.like(Expression<String> str) Create a this like str expression
BooleanExpression	StringExpression.like(Expression<String> str, char escape) Create a this like str expression
BooleanExpression	StringExpression.likeIgnoreCase(Expression<String> str) Create a this like str expression ignoring case
BooleanExpression	StringExpression.likeIgnoreCase(Expression<String> str, char escape) Create a this like str expression ignoring case
static <T> Expression<T>	Expressions.list(Class<T> clazz, Expression<?>... exprs) Combine the given expressions into a list expression
static Expression<Tuple>	Expressions.list(Expression<?>... exprs) Combine the given expressions into a list expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.ln(Expression<A> num) Create a ln(num) expression
NumberExpression<Integer>	StringExpression.locate(Expression<String> str) Create a locate(str, this) expression
NumberExpression<Integer>	StringExpression.locate(Expression<String> str, NumberExpression<Integer> start) Create a locate(str, this, start) expression
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.loe(Expression<A> right) Create a this <= right expression
BooleanExpression	ComparableExpression.loe(Expression<T> right) Create a this <= right expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.log(Expression<A> num, int base) Create a log(num, base) expression
static StringExpression	StringExpressions.lpad(Expression<String> in, Expression<Integer> length) Create a lpad(in, length) expression
static StringExpression	StringExpressions.lpad(Expression<String> in, Expression<Integer> length) Create a lpad(in, length) expression
static StringExpression	StringExpressions.lpad(Expression<String> in, int length) Create a lpad(in, length) expression
static StringExpression	StringExpressions.lpad(Expression<String> in, int length, char c) Create a lpad(in, length, c) expression
static StringExpression	StringExpressions.lpad(Expression<String> in, NumberExpression<Integer> length, char c) Create a lpad(in, length, c) expression
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.lt(Expression<A> right) Create a this < right expression
BooleanExpression	ComparableExpression.lt(Expression<T> right) Create a this < right expression
static StringExpression	StringExpressions.ltrim(Expression<String> str) Create a ltrim(str) expression
BooleanExpression	StringExpression.matches(Expression<String> regex) Create a this.matches(regex) expression
static <A extends Number & Comparable<?>> NumberExpression<A>	NumberExpression.max(Expression<A> left, Expression<A> right) Create a max(left, right) expression
static <A extends Number & Comparable<?>> NumberExpression<A>	NumberExpression.max(Expression<A> left, Expression<A> right) Create a max(left, right) expression
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.max(Expression<A> left, Expression<A> right) Create a max(left, right) expression
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.max(Expression<A> left, Expression<A> right) Create a max(left, right) expression
static <A extends Number & Comparable<?>> NumberExpression<A>	NumberExpression.min(Expression<A> left, Expression<A> right) Create a min(left, right) expression
static <A extends Number & Comparable<?>> NumberExpression<A>	NumberExpression.min(Expression<A> left, Expression<A> right) Create a min(left, right) expression
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.min(Expression<A> left, Expression<A> right) Create a min(left, right) expression
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.min(Expression<A> left, Expression<A> right) Create a min(left, right) expression
NumberExpression<T>	NumberExpression.mod(Expression<T> num) Create a mod(this, num) expression
<N extends Number & Comparable<?>> NumberExpression<T>	NumberExpression.multiply(Expression<N> right) Create a this * right expression
BooleanExpression	SimpleExpression.ne(Expression<? super T> right) Create a this <> right expression
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.notBetween(Expression<A> from, Expression<A> to) Create a this not between from and to expression
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.notBetween(Expression<A> from, Expression<A> to) Create a this not between from and to expression
BooleanExpression	ComparableExpression.notBetween(Expression<T> from, Expression<T> to) Create a this not between from and to expression
BooleanExpression	ComparableExpression.notBetween(Expression<T> from, Expression<T> to) Create a this not between from and to expression
BooleanExpression	StringExpression.notEqualsIgnoreCase(Expression<String> str) Create a !this.equalsIgnoreCase(str) expression
BooleanExpression	StringExpression.notLike(Expression<String> str) Create a this not like str expression
BooleanExpression	StringExpression.notLike(Expression<String> str, char escape) Create a this not like str expression
SimpleExpression<T>	SimpleExpression.nullif(Expression<T> other) Create a nullif(this, other) expression
static <T extends Number & Comparable<?>> NumberOperation<T>	Expressions.numberOperation(Class<? extends T> type, Operator operator, Expression<?>... args) Create a new Operation expression
static <T> SimpleOperation<T>	Expressions.operation(Class<? extends T> type, Operator operator, Expression<?>... args) Create a new Operation 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) Create a power(num, exponent) expression
static BooleanOperation	Expressions.predicate(Operator operator, Expression<?>... args) Create a new Predicate operation
StringExpression	StringExpression.prepend(Expression<String> str) Create a concat(str, this) expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.radians(Expression<A> num) Create a rad(num) expression
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) Create a rpad(in, length) expression
static StringExpression	StringExpressions.rpad(Expression<String> in, Expression<Integer> length) Create a rpad(in, length) expression
static StringExpression	StringExpressions.rpad(Expression<String> in, int length) Create a rpad(in, length) expression
static StringExpression	StringExpressions.rpad(Expression<String> in, int length, char c) Create a rpad(in, length, c) expression
static StringExpression	StringExpressions.rpad(Expression<String> in, NumberExpression<Integer> length, char c) Create a rpad(in, length, c) expression
static StringExpression	StringExpressions.rtrim(Expression<String> str) Create a rtrim(str) expression
static <A extends Number & Comparable<?>> NumberExpression<Integer>	MathExpressions.sign(Expression<A> num) Create a sign(num) expression
static <T> SimpleOperation<T>	Expressions.simpleOperation(Class<? extends T> type, Operator operator, Expression<?>... args) Create a new Operation expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.sin(Expression<A> num) Create a sin(num) expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.sinh(Expression<A> num) Create a sinh(num) expression
BooleanExpression	StringExpression.startsWith(Expression<String> str) Create a this.startsWith(str) expression
BooleanExpression	StringExpression.startsWithIgnoreCase(Expression<String> str) Create a this.startsWithIgnoreCase(str) expression
static StringOperation	Expressions.stringOperation(Operator operator, Expression<?>... args) Create a new Operation expression
StringExpression	StringExpression.substring(Expression<Integer> beginIndex) Create a this.substring(beginIndex) expression
StringExpression	StringExpression.substring(Expression<Integer> beginIndex, Expression<Integer> endIndex) Create a this.substring(beginIndex, endIndex) expression
StringExpression	StringExpression.substring(Expression<Integer> beginIndex, Expression<Integer> endIndex) Create a this.substring(beginIndex, endIndex) expression
StringExpression	StringExpression.substring(Expression<Integer> beginIndex, int endIndex) Create a this.substring(beginIndex, endIndex) expression
StringExpression	StringExpression.substring(int beginIndex, Expression<Integer> endIndex) Create a this.substring(beginIndex, endIndex) expression
<N extends Number & Comparable<?>> NumberExpression<T>	NumberExpression.subtract(Expression<N> right) Create a this - right expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.tan(Expression<A> num) Create a tan(num) expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.tanh(Expression<A> num) Create a tanh(num) expression
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> expr)
<T extends Number & Comparable<?>> CaseForEqBuilder.Cases<T,NumberExpression<T>>	CaseForEqBuilder.thenNumber(Expression<T> then)
static <T extends Comparable<?>> TimeOperation<T>	Expressions.timeOperation(Class<? extends T> type, Operator operator, Expression<?>... args) Create a new Operation expression
CaseForEqBuilder.CaseWhen<T,Q>	CaseForEqBuilder.Cases.when(Expression<? extends D> when)
CaseForEqBuilder<T>	SimpleExpression.when(Expression<? extends T> other) Create a case expression builder

Constructors in com.querydsl.core.types.dsl with parameters of type Expression

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

Constructor parameters in com.querydsl.core.types.dsl with type arguments of type Expression

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