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	Description
final class	BooleanBuilder	BooleanBuilder is a cascading builder for Predicate expressions.

Methods in com.querydsl.core that return Expression

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

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

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

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

Modifier and Type	Method	Description
void	DefaultQueryMetadata.addGroupBy(Expression<?> o)
void	EmptyMetadata.addGroupBy(Expression<?> o)
void	QueryMetadata.addGroupBy(Expression<?> o)	Add the given group by expressions
void	DefaultQueryMetadata.addJoin(JoinType joinType, Expression<?> expr)
void	EmptyMetadata.addJoin(JoinType joinType, Expression<?> expr)
void	QueryMetadata.addJoin(JoinType joinType, Expression<?> expr)	Add the given query join
<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	DefaultQueryMetadata.setProjection(Expression<?> o)
void	EmptyMetadata.setProjection(Expression<?> o)
void	QueryMetadata.setProjection(Expression<?> o)	Set the projection

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

Modifier	Constructor	Description
	JoinExpression(JoinType type, Expression<?> target)	Create a new JoinExpression instance
	JoinExpression(JoinType type, Expression<?> target, @Nullable 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	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	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	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	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	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	Description
class	AbstractGroupExpression<T,R>	A base class for GroupExpressions
class	MixinGroupExpression<E,F,R>	MixinGroupExpression provides nesting support for GroupExpression instances
final class	QPair<K,V>	A pair of (Map) key and value

Fields in com.querydsl.core.group declared as Expression

Modifier and Type	Field	Description
protected final Expression<?>[]	AbstractGroupByTransformer.expressions
protected final Expression<K>	GroupByBuilder.key

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

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

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

Modifier and Type	Method	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
<RES extends Map<K, Group>> ResultTransformer<RES>	GroupByBuilder.as(Supplier<RES> mapFactory, Expression<?>... expressions)	Get the results as a map
<V, RES extends Map<K, V>> ResultTransformer<RES>	GroupByBuilder.as(Supplier<RES> mapFactory, 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, uses default MathContext.DECIMAL128 for average calculation
static <E extends Number> AbstractGroupExpression<E,E>	GroupBy.avg(Expression<E> expression, MathContext mathContext)	Create a new aggregating avg expression with a user-provided MathContext
<RES extends Collection<Group>> ResultTransformer<RES>	GroupByBuilder.collection(Supplier<RES> resultFactory, Expression<?>... expressions)	Get the results as a collection.
<V, RES extends Collection<V>> ResultTransformer<RES>	GroupByBuilder.collection(Supplier<RES> resultFactory, Expression<V> expression)	Get the results as a set
static <K, V> QPair<K,V>	QPair.create(Expression<K> key, Expression<V> value)
boolean	QPair.equals(Expression<?> keyExpr, Expression<?> valueExpr)
boolean	QPair.equals(Expression<?> keyExpr, Class<?> valueType)
<T> List<T>	Group.getList(Expression<T> expr)	Returns a List of values in this group.
<T> List<T>	GroupImpl.getList(Expression<T> expr)
protected <V> Expression<V>	GroupByBuilder.getLookup(Expression<V> expression)
<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>	GroupImpl.getMap(Expression<K> key, Expression<V> value)
<T> T	Group.getOne(Expression<T> expr)	Returns the value of the given single valued expression.
<T> T	GroupImpl.getOne(Expression<T> expr)
<T> Set<T>	Group.getSet(Expression<T> expr)	Returns a Set of values in this group.
<T> Set<T>	GroupImpl.getSet(Expression<T> expr)
<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>	GroupImpl.getSortedMap(Expression<K> key, Expression<V> value)
<T> SortedSet<T>	Group.getSortedSet(Expression<T> expr)	Returns a SortedSet of values in this group.
<T> SortedSet<T>	GroupImpl.getSortedSet(Expression<T> expr)
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
static <E> AbstractGroupExpression<E,List<E>>	GroupBy.list(Expression<E> expression)	Create a new aggregating list expression
ResultTransformer<List<Group>>	GroupByBuilder.list(Expression<?>... expressions)	Get the results as a list
<V> ResultTransformer<List<V>>	GroupByBuilder.list(Expression<V> expression)	Get the results as a list
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 <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> 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 <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, 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 <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 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 <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

Modifier	Constructor	Description
protected	AbstractGroupByTransformer(Expression<K> key, Expression<?>... expressions)
	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)
	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	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	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	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<?>	CollectionAnyVisitor.visit(Constant<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(FactoryExpression<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(Operation<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(ParamExpression<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(Path<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(SubQueryExpression<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(TemplateExpression<?> expr, Context context)
Expression<?>	ReplaceVisitor.visit(Constant<?> expr, C context)
Expression<?>	ReplaceVisitor.visit(FactoryExpression<?> expr, C context)
Expression<?>	ReplaceVisitor.visit(Operation<?> expr, C context)
Expression<?>	ReplaceVisitor.visit(ParamExpression<?> expr, C context)
Expression<?>	ReplaceVisitor.visit(Path<?> expr, C context)
Expression<?>	ReplaceVisitor.visit(SubQueryExpression<?> expr, C context)
Expression<?>	ReplaceVisitor.visit(TemplateExpression<?> expr, C context)

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

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

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

Modifier and Type	Method	Description
void	OrderedQueryMetadata.addJoin(JoinType joinType, Expression<?> expr)
T	QueryMixin.addJoin(JoinType joinType, Expression<?> target)
BooleanExpression	ExtendedSubQuery.contains(Expression<? extends T> right)	Create a right in this expression
BooleanExpression	FetchableSubQueryBase.contains(Expression<? extends T> right)
<RT> Expression<RT>	QueryMixin.convert(Expression<RT> expr, QueryMixin.Role role)
protected <D> Expression<D>	QueryMixin.createAlias(Expression<?> expr, Path<D> alias)
BooleanExpression	ExtendedSubQuery.eq(Expression<? extends T> expr)	Create a this == right expression
BooleanExpression	FetchableSubQueryBase.eq(Expression<? extends T> expr)
final T	QueryMixin.from(Expression<?> arg)
final T	QueryMixin.from(Expression<?>... args)
final T	QueryMixin.fullJoin(Expression<?> target)
final <P> T	QueryMixin.fullJoin(Expression<P> target, Path<P> alias)
BooleanExpression	ExtendedSubQuery.goe(Expression<? extends T> expr)	Create a this >= right expression
BooleanExpression	FetchableSubQueryBase.goe(Expression<? extends T> expr)
Q	QueryBase.groupBy(Expression<?> e)	Add a single grouping expression
Q	QueryBase.groupBy(Expression<?>... o)	Add grouping/aggregation expressions
final T	QueryMixin.groupBy(Expression<?> e)
final T	QueryMixin.groupBy(Expression<?>... o)
BooleanExpression	ExtendedSubQuery.gt(Expression<? extends T> expr)	Create a this > right expression
BooleanExpression	FetchableSubQueryBase.gt(Expression<? extends T> expr)
final S	SerializerBase.handle(Expression<?> expr)
final S	SerializerBase.handle(String sep, Expression<?>[] expressions)
final <P> T	QueryMixin.innerJoin(Expression<P> target)
final <P> T	QueryMixin.innerJoin(Expression<P> target, Path<P> alias)
final <P> T	QueryMixin.join(Expression<P> target)
final <P> T	QueryMixin.join(Expression<P> target, Path<P> alias)
final <P> T	QueryMixin.leftJoin(Expression<P> target)
final <P> T	QueryMixin.leftJoin(Expression<P> target, Path<P> alias)
BooleanExpression	ExtendedSubQuery.loe(Expression<? extends T> expr)	Create a this <= right expression
BooleanExpression	FetchableSubQueryBase.loe(Expression<? extends T> expr)
BooleanExpression	ExtendedSubQuery.lt(Expression<? extends T> expr)	Create a this < right expression
BooleanExpression	FetchableSubQueryBase.lt(Expression<? extends T> expr)
BooleanExpression	ExtendedSubQuery.ne(Expression<? extends T> expr)	Create a this != right expression
BooleanExpression	FetchableSubQueryBase.ne(Expression<? extends T> expr)
final <P> T	QueryMixin.rightJoin(Expression<P> target)
final <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	Description
final 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

Modifier	Constructor	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	Description
interface	CollectionExpression<T extends Collection<E>,E>	CollectionExpression represents java.util.Collection typed expressions
interface	Constant<T>	Constant represents a general constant expression.
interface	EntityPath<T>	EntityPath is the common interface for entity path expressions
interface	FactoryExpression<T>	FactoryExpression represents factory expressions such as JavaBean or Constructor projections
interface	MapExpression<K,V>	MapExpression represents java.util.Map typed expressions
interface	Operation<T>	Operation represents an operation with operator and arguments
interface	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	Description
class	ArrayConstructorExpression<T>	ArrayConstructorExpression extends FactoryExpressionBase to represent array initializers
final 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
final 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
final 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	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
Expression<T>	ConstructorExpression.as(Path<T> alias)	Create an alias for the expression
Expression<T>	ConstructorExpression.as(String alias)	Create an alias for the 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>	QBean.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<?>	Operation.getArg(int index)	Get the argument with the given index
final 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)	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	Description
static List<Expression<?>>	ExpressionUtils.distinctList(Expression<?>... args)	Create a distinct list of the given args
static List<Expression<?>>	ExpressionUtils.distinctList(Expression<?>[]... args)	Create a distinct list of the concatenated array contents
@Unmodifiable List<Expression<?>>	ArrayConstructorExpression.getArgs()
final @Unmodifiable List<Expression<?>>	ConstructorExpression.getArgs()
List<Expression<?>>	FactoryExpression.getArgs()	Get the invocation arguments
List<Expression<?>>	FactoryExpressionUtils.FactoryExpressionAdapter.getArgs()
List<Expression<?>>	MappingProjection.getArgs()
@Unmodifiable List<Expression<?>>	Operation.getArgs()	Get the arguments of this operation
final @Unmodifiable List<Expression<?>>	OperationImpl.getArgs()
List<Expression<?>>	QBean.getArgs()
@Unmodifiable List<Expression<?>>	QList.getArgs()
@Unmodifiable List<Expression<?>>	QMap.getArgs()
@Unmodifiable List<Expression<?>>	QTuple.getArgs()
@Nullable 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	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> 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(Path<? extends T> type, Expression<?>... exprs)	Create a Bean populating projection for the given type and expressions
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> ConstructorExpression<T>	Projections.constructor(Class<? extends T> type, Expression<?>... exprs)	Create a constructor invocation 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 Expression<Long>	ExpressionUtils.count(Expression<?> source)	Create a count(source) expression
static List<Expression<?>>	ExpressionUtils.distinctList(Expression<?>... args)	Create a distinct list of the given args
static List<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.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(Path<? 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(Class<? 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, 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.in(Expression<D> left, Collection<? 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.neConst(Expression<D> left, D constant)	Create a left != constant 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.notIn(Expression<D> left, Collection<? 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	Description
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> 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> ConstructorExpression<T>	Projections.constructor(Class<? extends T> type, Class<?>[] paramTypes, List<Expression<?>> exprs)	Create a constructor invocation projection for given type, parameter types and expressions
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> 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> Expression<T>	ExpressionUtils.list(Class<T> clazz, List<? extends Expression<?>> exprs)	Create a list expression for the given arguments
static QList	Projections.list(List<Expression<?>> args)	Create a new List typed projection for the given expressions
static <T> Operation<T>	ExpressionUtils.operation(Class<? extends T> type, Operator operator, List<Expression<?>> args)	Create a new Operation expression
static PredicateOperation	ExpressionUtils.predicate(Operator operator, List<Expression<?>> args)	Create a new Operation expression
static QTuple	Projections.tuple(List<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

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

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

Modifier	Constructor	Description
protected	ConstructorExpression(Class<? extends T> type, Class<?>[] paramTypes, List<Expression<?>> args)
protected	OperationImpl(Class<? extends T> type, Operator operator, List<Expression<?>> args)
protected	PredicateOperation(Operator operator, List<Expression<?>> args)
protected	QBean(Class<? extends T> type, boolean fieldAccess, Map<String,? extends Expression<?>> bindings)	Create a new QBean instance
protected	QBean(Class<? extends T> type, Map<String,? extends Expression<?>> bindings)	Create a new QBean instance
protected	QList(List<Expression<?>> args)	Create a new QList instance
protected	QMap(List<Expression<?>> args)	Create a new QMap instance
protected	QTuple(List<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	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	Description
interface	ArrayExpression<A,T>	ArrayExpression defines an interface for array typed expression
interface	ListExpression<E,Q extends SimpleExpression<? super E>>	ListExpression represents java.util.List typed expressions

Classes in com.querydsl.core.types.dsl that implement Expression

Modifier and Type	Class	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	Description
static final Expression<Object[]>	Wildcard.all	Wildcard expression (*) for all columns
protected final Expression<T>	DslExpression.mixin

Methods in com.querydsl.core.types.dsl that return Expression

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

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

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

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

Modifier and Type	Method	Description
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.acos(Expression<A> num)	Create a acos(num) expression
final Coalesce<T>	Coalesce.add(Expression<T> expr)
<N extends Number & Comparable<?>> NumberExpression<T>	NumberExpression.add(Expression<N> right)	Create a this + right expression
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
BooleanExpression	ComparableExpression.between(@Nullable Expression<T> from, @Nullable Expression<T> to)	Create a this between from and to expression
final <A extends Number & Comparable<?>> BooleanExpression	NumberExpression.between(@Nullable Expression<A> from, @Nullable Expression<A> 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
BooleanExpression	BooleanExpression.coalesce(Expression<?>... exprs)	Create a coalesce(this, exprs...) expression
BooleanExpression	BooleanExpression.coalesce(Expression<Boolean> expr)	Create a coalesce(this, expr) expression
ComparableExpression<T>	ComparableExpression.coalesce(Expression<?>... exprs)	Create a coalesce(this, exprs...) expression
ComparableExpression<T>	ComparableExpression.coalesce(Expression<T> expr)	Create a coalesce(this, expr) expression
ComparableExpressionBase<T>	ComparableExpressionBase.coalesce(Expression<?>... exprs)	Create a coalesce(this, exprs...) expression
ComparableExpressionBase<T>	ComparableExpressionBase.coalesce(Expression<T> expr)	Create a coalesce(this, expr) expression
DateExpression<T>	DateExpression.coalesce(Expression<?>... exprs)	Create a coalesce(this, exprs...) expression
DateExpression<T>	DateExpression.coalesce(Expression<T> expr)	Create a coalesce(this, expr) expression
DateTimeExpression<T>	DateTimeExpression.coalesce(Expression<?>... exprs)	Create a coalesce(this, exprs...) expression
DateTimeExpression<T>	DateTimeExpression.coalesce(Expression<T> expr)	Create a coalesce(this, expr) expression
EnumExpression<T>	EnumExpression.coalesce(Expression<?>... exprs)	Create a coalesce(this, exprs...) expression
EnumExpression<T>	EnumExpression.coalesce(Expression<T> expr)	Create a coalesce(this, expr) expression
NumberExpression<T>	NumberExpression.coalesce(Expression<?>... exprs)	Create a coalesce(this, exprs...) expression
NumberExpression<T>	NumberExpression.coalesce(Expression<T> expr)	Create a coalesce(this, expr) expression
StringExpression	StringExpression.coalesce(Expression<?>... exprs)	Create a coalesce(this, exprs...) expression
StringExpression	StringExpression.coalesce(Expression<String> expr)	Create a coalesce(this, expr) expression
TimeExpression<T>	TimeExpression.coalesce(Expression<?>... exprs)	Create a coalesce(this, exprs...) expression
TimeExpression<T>	TimeExpression.coalesce(Expression<T> expr)	Create a coalesce(this, expr) 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
final BooleanExpression	CollectionExpressionBase.contains(Expression<E> child)	Create a this.contains(child) expression
final 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
final BooleanExpression	MapExpressionBase.containsKey(Expression<K> key)	Create a key in keys(this) expression
final 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)
SimpleExpression<T>	ArrayExpression.get(Expression<Integer> index)	Create a this[index] expression
SimplePath<E>	ArrayPath.get(Expression<Integer> index)
Q	ListExpression.get(Expression<Integer> index)	Indexed access, gets the element at the given index
Q	ListPath.get(Expression<Integer> index)
abstract Q	MapExpressionBase.get(Expression<K> key)	Create a this.get(key) expression
E	MapPath.get(Expression<K> key)
BooleanExpression	ComparableExpression.goe(Expression<T> right)	Create a this >= right expression
final <A extends Number & Comparable<?>> BooleanExpression	NumberExpression.goe(Expression<A> right)	Create a this >= right expression
BooleanExpression	ComparableExpression.gt(Expression<T> right)	Create a this > right expression
final <A extends Number & Comparable<?>> BooleanExpression	NumberExpression.gt(Expression<A> 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	NumberExpression.like(Expression<String> str)	Create a this like str expression
BooleanExpression	StringExpression.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 Expression<Tuple>	Expressions.list(Expression<?>... exprs)	Combine the given expressions into a list expression
static <T> Expression<T>	Expressions.list(Class<T> clazz, 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
NumberExpression<Integer>	StringExpression.locate(String str, Expression<Integer> start)	Create a locate(str, this, start) expression
BooleanExpression	ComparableExpression.loe(Expression<T> right)	Create a this <= right expression
final <A extends Number & Comparable<?>> BooleanExpression	NumberExpression.loe(Expression<A> 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, 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
static StringExpression	StringExpressions.lpad(Expression<String> in, Expression<Integer> length)	Create a lpad(in, length) expression
BooleanExpression	ComparableExpression.lt(Expression<T> right)	Create a this < right expression
final <A extends Number & Comparable<?>> BooleanExpression	NumberExpression.lt(Expression<A> 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>	MathExpressions.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.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
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
BooleanExpression	ComparableExpression.notBetween(Expression<T> from, Expression<T> to)	Create a this not between from and to expression
final <A extends Number & Comparable<?>> BooleanExpression	NumberExpression.notBetween(Expression<A> from, Expression<A> to)	Create a this not between from and to expression
BooleanExpression	StringExpression.notEqualsIgnoreCase(Expression<String> str)	Create a !this.equalsIgnoreCase(str) expression
BooleanExpression	SimpleExpression.notIn(Expression<? extends T>... right)	Create a this not in right 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
BooleanExpression	BooleanExpression.nullif(Expression<Boolean> other)	Create a nullif(this, other) expression
ComparableExpression<T>	ComparableExpression.nullif(Expression<T> other)	Create a nullif(this, other) expression
ComparableExpressionBase<T>	ComparableExpressionBase.nullif(Expression<T> other)	Create a nullif(this, other) expression
DateExpression<T>	DateExpression.nullif(Expression<T> other)	Create a nullif(this, other) expression
DateTimeExpression<T>	DateTimeExpression.nullif(Expression<T> other)	Create a nullif(this, other) expression
EnumExpression<T>	EnumExpression.nullif(Expression<T> other)	Create a nullif(this, other) expression
NumberExpression<T>	NumberExpression.nullif(Expression<T> other)	Create a nullif(this, other) expression
SimpleExpression<T>	SimpleExpression.nullif(Expression<T> other)	Create a nullif(this, other) expression
StringExpression	StringExpression.nullif(Expression<String> other)	Create a nullif(this, other) expression
TimeExpression<T>	TimeExpression.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, 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.rpad(Expression<String> in, Expression<Integer> length)	Create a rpad(in, length) expression
static StringExpression	StringExpressions.rtrim(Expression<String> str)	Create a rtrim(str) expression
static Expression<Tuple>	Expressions.set(Expression<?>... exprs)	Combine the given expressions into a set expression
static <T> Expression<T>	Expressions.set(Class<T> clazz, Expression<?>... exprs)	Combine the given expressions into a set 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(int beginIndex, Expression<Integer> endIndex)	Create a this.substring(beginIndex, endIndex) expression
StringExpression	StringExpression.substring(Expression<Integer> beginIndex)	Create a this.substring(beginIndex) expression
StringExpression	StringExpression.substring(Expression<Integer> beginIndex, int endIndex)	Create a this.substring(beginIndex, endIndex) expression
StringExpression	StringExpression.substring(Expression<Integer> 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<D>.Cases<T,Q>	CaseForEqBuilder.CaseWhen.then(Expression<T> then)
<T> CaseForEqBuilder<D>.Cases<T,Expression<T>>	CaseForEqBuilder.then(Expression<T> expr)
<T extends Number & Comparable<?>> CaseForEqBuilder<D>.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<D>.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

Modifier	Constructor	Description
	BooleanExpression(Expression<Boolean> mixin)
protected	BooleanOperation(Operator op, Expression<?>... args)
	CaseForEqBuilder(Expression<D> base, Expression<? extends D> other)
	CaseWhen(CaseForEqBuilder<D>.Cases<T,Q> cases, Expression<? extends D> when)
	Coalesce(Expression... exprs)
	Coalesce(Class<? extends T> type, Expression<?>... exprs)
	Coalesce(Class<? extends T> type, Expression<T> expr)
	CollectionExpressionBase(Expression<T> mixin)
protected	CollectionOperation(Class<? super E> type, Operator op, Expression<?>... args)
	ComparableExpression(Expression<T> mixin)
	ComparableExpressionBase(Expression<T> mixin)
protected	ComparableOperation(Class<? extends T> type, Operator op, Expression<?>... args)
	DateExpression(Expression<T> mixin)
protected	DateOperation(Class<? extends T> type, Operator op, Expression<?>... args)
	DateTimeExpression(Expression<T> mixin)
protected	DateTimeOperation(Class<? extends T> type, Operator op, Expression<?>... args)
	DslExpression(Expression<T> mixin)
protected	DslOperation(Class<? extends T> type, Operator op, Expression<?>... args)
	EnumExpression(Expression<T> mixin)
protected	EnumOperation(Class<? extends T> type, Operator op, Expression<?>... args)
	LiteralExpression(Expression<T> mixin)
	MapExpressionBase(Expression<Map<K,V>> mixin)
	NumberExpression(Expression<T> mixin)
protected	NumberOperation(Class<? extends T> type, Operator op, Expression<?>... args)
	SimpleExpression(Expression<T> mixin)
protected	SimpleOperation(Class<? extends T> type, Operator op, Expression<?>... args)
	StringExpression(Expression<String> mixin)
protected	StringOperation(Operator op, Expression<?>... args)
	TemporalExpression(Expression<T> mixin)
	TimeExpression(Expression<T> mixin)
protected	TimeOperation(Class<? extends T> type, Operator op, Expression<?>... args)

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

Modifier	Constructor	Description
protected	BooleanOperation(Operator op, List<Expression<?>> args)
protected	CollectionOperation(Class<? super E> type, Operator op, List<Expression<?>> args)
protected	ComparableOperation(Class<? extends T> type, Operator op, List<Expression<?>> args)
protected	DateOperation(Class<? extends T> type, Operator op, List<Expression<?>> args)
protected	DateTimeOperation(Class<? extends T> type, Operator op, List<Expression<?>> args)
protected	DslOperation(Class<? extends T> type, Operator op, List<Expression<?>> args)
protected	EnumOperation(Class<? extends T> type, Operator op, List<Expression<?>> args)
protected	NumberOperation(Class<? extends T> type, Operator op, List<Expression<?>> args)
protected	SimpleOperation(Class<? extends T> type, Operator op, List<Expression<?>> args)
protected	StringOperation(Operator op, List<Expression<?>> args)
protected	TimeOperation(Class<? extends T> type, Operator op, List<Expression<?>> args)