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

Packages that use Expression

Package	Description
com.querydsl.apt	APT-related classes
com.querydsl.codegen	Code generations models and serializers
com.querydsl.collections	Java Bean collections support
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
com.querydsl.jdo	JDO support
com.querydsl.jdo.dml	DML operations support
com.querydsl.jdo.sql	SQL queries for JDO
com.querydsl.jpa	JPA support
com.querydsl.jpa.hibernate	JPQL for Hibernate
com.querydsl.jpa.hibernate.sql	Native queries for Hibernate
com.querydsl.jpa.impl	JPQL for JPA
com.querydsl.jpa.sql	Native queries for JPA
com.querydsl.lucene3	Lucene 3 support
com.querydsl.lucene4	Lucene 4 support
com.querydsl.lucene5	Lucene 5 support
com.querydsl.mongodb	MongoDB support
com.querydsl.spatial	Spatial types using Geolatte
com.querydsl.spatial.jts	Spatial types using JTS
com.querydsl.sql	SQL/JDBC support
com.querydsl.sql.dml	DML operations support
com.querydsl.sql.mssql	SQL Server support
com.querydsl.sql.mysql	MySQL support
com.querydsl.sql.oracle	Oracle support
com.querydsl.sql.postgresql	PostgreSQL support
com.querydsl.sql.spatial	Spatial support
com.querydsl.sql.teradata	Teradata support

Uses of Expression in com.querydsl.apt

Method parameters in com.querydsl.apt with type arguments of type Expression

Modifier and Type	Method and Description
<T> void	DefaultConfiguration.addCustomType(Class<T> type, Class<? extends Expression<T>> queryType)

Uses of Expression in com.querydsl.codegen

Method parameters in com.querydsl.codegen with type arguments of type Expression

Modifier and Type	Method and Description
void	TypeMappings.register(com.mysema.codegen.model.TypeCategory category, Class<? extends Expression> expr, Class<? extends Path> path, Class<? extends TemplateExpression> template)

Uses of Expression in com.querydsl.collections

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

Modifier and Type	Method and Description
static Number	CollQueryFunctions.aggregate(Collection<Number> source, Expression<?> expr, Operator aggregator)
<T> com.mysema.codegen.Evaluator<T>	DefaultEvaluatorFactory.create(QueryMetadata metadata, List<? extends Expression<?>> sources, Expression<T> projection) Create an Evaluator for the given query sources and projection
<T> com.mysema.codegen.Evaluator<List<T>>	DefaultEvaluatorFactory.createEvaluator(QueryMetadata metadata, Expression<? extends T> source, Predicate filter) Create an Evaluator for the given source and filter
Q	AbstractCollQuery.groupBy(Expression<?>... o)
Q	AbstractCollQuery.groupBy(Expression<?> e)
<T> List<T>	QueryEngine.list(QueryMetadata metadata, Map<Expression<?>,Iterable<?>> iterables, Expression<T> projection) Evaluate the given query and return the projection as a list
<T> List<T>	DefaultQueryEngine.list(QueryMetadata metadata, Map<Expression<?>,Iterable<?>> iterables, Expression<T> projection)
CollQuery<Tuple>	CollQuery.select(Expression<?>... exprs)
<E> CollQuery<E>	CollQuery.select(Expression<E> expr)
<U> CollUpdateClause<T>	CollUpdateClause.set(Path<U> path, Expression<? extends U> expression)
static <F,T> com.google.common.base.Function<F,T>	GuavaHelpers.wrap(Expression<T> projection) Wrap a Querydsl expression into a Guava function

Method parameters in com.querydsl.collections with type arguments of type Expression

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

Uses of Expression in com.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
static <T> Expression<T>	Expressions.set(Class<T> clazz, Expression<?>... exprs) Combine the given expressions into a set expression
static Expression<Tuple>	Expressions.set(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 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
NumberExpression<Integer>	StringExpression.locate(String str, Expression<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	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
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 <T> Expression<T>	Expressions.set(Class<T> clazz, Expression<?>... exprs) Combine the given expressions into a set expression
static Expression<Tuple>	Expressions.set(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(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)

Uses of Expression in com.querydsl.jdo

Subinterfaces of Expression in com.querydsl.jdo

Modifier and Type	Interface and Description
interface	JDOQLQuery<T> Query interface for JDOQL queries

Classes in com.querydsl.jdo that implement Expression

Modifier and Type	Class and Description
class	AbstractJDOQuery<T,Q extends AbstractJDOQuery<T,Q>> Abstract base class for custom implementations of the JDOQLQuery interface.
class	JDOQuery<T> JDOQuery is the default implementation of the JDOQLQuery interface

Methods in com.querydsl.jdo that return Expression

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

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

Modifier and Type	Method and Description
JDOQuery<Tuple>	JDOQueryFactory.select(Expression<?>... exprs) Create a new JDOQuery instance with the given projection
JDOQuery<Tuple>	JDOQuery.select(Expression<?>... exprs)
static JDOQuery<Tuple>	JDOExpressions.select(Expression<?>... exprs) Create a new detached JDOQuery instance with the given projection
<T> JDOQuery<T>	JDOQueryFactory.select(Expression<T> expr) Create a new JDOQuery instance with the given projection
static <T> JDOQuery<T>	JDOExpressions.select(Expression<T> expr) Create a new detached JDOQuery instance with the given projection
<U> JDOQuery<U>	JDOQuery.select(Expression<U> expr)
JDOQuery<Tuple>	JDOQueryFactory.selectDistinct(Expression<?>... exprs) Create a new JDOQuery instance with the given projection
static JDOQuery<Tuple>	JDOExpressions.selectDistinct(Expression<?>... exprs) Create a new detached JDOQuery instance with the given projection
<T> JDOQuery<T>	JDOQueryFactory.selectDistinct(Expression<T> expr) Create a new JDOQuery instance with the given projection
static <T> JDOQuery<T>	JDOExpressions.selectDistinct(Expression<T> expr) Create a new detached JDOQuery instance with the given projection

Method parameters in com.querydsl.jdo with type arguments of type Expression

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

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

Constructor and Description
JDOQLSerializer(JDOQLTemplates templates, Expression<?> candidate)

Uses of Expression in com.querydsl.jdo.dml

Methods in com.querydsl.jdo.dml with parameters of type Expression

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

Uses of Expression in com.querydsl.jdo.sql

Classes in com.querydsl.jdo.sql that implement Expression

Modifier and Type	Class and Description
class	JDOSQLQuery<T> JDOSQLQuery is a SQLQuery implementation that uses JDO's SQL query functionality to execute queries

Methods in com.querydsl.jdo.sql with parameters of type Expression

Modifier and Type	Method and Description
JDOSQLQuery<Tuple>	JDOSQLQuery.select(Expression<?>... exprs)
<U> JDOSQLQuery<U>	JDOSQLQuery.select(Expression<U> expr)

Uses of Expression in com.querydsl.jpa

Subinterfaces of Expression in com.querydsl.jpa

Modifier and Type	Interface and Description
interface	JPQLQuery<T> Query interface for JPQL queries

Classes in com.querydsl.jpa that implement Expression

Modifier and Type	Class and Description
class	JPAQueryBase<T,Q extends JPAQueryBase<T,Q>> JPAQueryBase is a base Query class for JPA queries

Methods in com.querydsl.jpa that return Expression

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

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

Modifier and Type	Method and Description
com.google.common.collect.ListMultimap<Expression<?>,String>	NativeSQLSerializer.getAliases()

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

Modifier and Type	Method and Description
static <RT> Expression<RT>	Conversions.convert(Expression<RT> expr)
<RT> Expression<RT>	JPAQueryMixin.convert(Expression<RT> expr, QueryMixin.Role role)
static <RT> Expression<RT>	Conversions.convertForNativeQuery(Expression<RT> expr)
protected <D> Expression<D>	JPAQueryMixin.createAlias(Expression<?> expr, Path<D> alias)
protected Expression<?>	AbstractSQLQuery.extractEntityExpression(Expression<?> expr)
protected boolean	AbstractSQLQuery.isEntityExpression(Expression<?> expr)
JPQLQuery<Tuple>	JPQLQueryFactory.select(Expression<?>... exprs) Create a new JPQLQuery instance with the given projection
JPQLQuery<Tuple>	JPQLQuery.select(Expression<?>... exprs)
static JPQLQuery<Tuple>	JPAExpressions.select(Expression<?>... exprs) Create a new detached JPQLQuery instance with the given projection
<T> JPQLQuery<T>	JPQLQueryFactory.select(Expression<T> expr) Create a new JPQLQuery instance with the given projection
static <T> JPQLQuery<T>	JPAExpressions.select(Expression<T> expr) Create a new detached JPQLQuery instance with the given projection
<U> JPQLQuery<U>	JPQLQuery.select(Expression<U> expr)
JPQLQuery<Tuple>	JPQLQueryFactory.selectDistinct(Expression<?>... exprs) Create a new JPQLQuery instance with the given projection
static JPQLQuery<Tuple>	JPAExpressions.selectDistinct(Expression<?>... exprs) Create a new detached JPQLQuery instance with the given projection
<T> JPQLQuery<T>	JPQLQueryFactory.selectDistinct(Expression<T> expr) Create a new JPQLQuery instance with the given projection
static <T> JPQLQuery<T>	JPAExpressions.selectDistinct(Expression<T> expr) Create a new detached JPQLQuery instance with the given projection

Method parameters in com.querydsl.jpa with type arguments of type Expression

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

Uses of Expression in com.querydsl.jpa.hibernate

Classes in com.querydsl.jpa.hibernate that implement Expression

Modifier and Type	Class and Description
class	AbstractHibernateQuery<T,Q extends AbstractHibernateQuery<T,Q>> Abstract base class for Hibernate API based implementations of the JPQL interface
class	HibernateQuery<T> HibernateQuery is the default implementation of the JPQLQuery interface for Hibernate

Methods in com.querydsl.jpa.hibernate with parameters of type Expression

Modifier and Type	Method and Description
HibernateQuery<Tuple>	HibernateQueryFactory.select(Expression<?>... exprs)
HibernateQuery<Tuple>	HibernateQuery.select(Expression<?>... exprs)
<T> HibernateQuery<T>	HibernateQueryFactory.select(Expression<T> expr)
<U> HibernateQuery<U>	HibernateQuery.select(Expression<U> expr)
HibernateQuery<Tuple>	HibernateQueryFactory.selectDistinct(Expression<?>... exprs)
<T> HibernateQuery<T>	HibernateQueryFactory.selectDistinct(Expression<T> expr)
<T> HibernateUpdateClause	HibernateUpdateClause.set(Path<T> path, Expression<? extends T> expression)

Uses of Expression in com.querydsl.jpa.hibernate.sql

Classes in com.querydsl.jpa.hibernate.sql that implement Expression

Modifier and Type	Class and Description
class	AbstractHibernateSQLQuery<T,Q extends AbstractHibernateSQLQuery<T,Q>> AbstractHibernateSQLQuery is the base class for Hibernate Native SQL queries
class	HibernateSQLQuery<T> HibernateSQLQuery is an SQLQuery implementation that uses Hibernate's Native SQL functionality to execute queries

Methods in com.querydsl.jpa.hibernate.sql with parameters of type Expression

Modifier and Type	Method and Description
HibernateSQLQuery<Tuple>	HibernateSQLQuery.select(Expression<?>... exprs)
<U> HibernateSQLQuery<U>	HibernateSQLQuery.select(Expression<U> expr)

Uses of Expression in com.querydsl.jpa.impl

Classes in com.querydsl.jpa.impl that implement Expression

Modifier and Type	Class and Description
class	AbstractJPAQuery<T,Q extends AbstractJPAQuery<T,Q>> Abstract base class for JPA API based implementations of the JPQLQuery interface
class	JPAQuery<T> JPAQuery is the default implementation of the JPQLQuery interface for JPA

Methods in com.querydsl.jpa.impl with parameters of type Expression

Modifier and Type	Method and Description
JPAQuery<Tuple>	JPAQueryFactory.select(Expression<?>... exprs)
JPAQuery<Tuple>	JPAQuery.select(Expression<?>... exprs)
<T> JPAQuery<T>	JPAQueryFactory.select(Expression<T> expr)
<U> JPAQuery<U>	JPAQuery.select(Expression<U> expr)
JPAQuery<Tuple>	JPAQueryFactory.selectDistinct(Expression<?>... exprs)
<T> JPAQuery<T>	JPAQueryFactory.selectDistinct(Expression<T> expr)
<T> JPAUpdateClause	JPAUpdateClause.set(Path<T> path, Expression<? extends T> expression)

Uses of Expression in com.querydsl.jpa.sql

Classes in com.querydsl.jpa.sql that implement Expression

Modifier and Type	Class and Description
class	AbstractJPASQLQuery<T,Q extends AbstractJPASQLQuery<T,Q>> AbstractJPASQLQuery is the base class for JPA Native SQL queries
class	JPASQLQuery<T> JPASQLQuery is an SQLQuery implementation that uses JPA Native SQL functionality to execute queries

Methods in com.querydsl.jpa.sql with parameters of type Expression

Modifier and Type	Method and Description
JPASQLQuery<Tuple>	JPASQLQuery.select(Expression<?>... exprs)
<U> JPASQLQuery<U>	JPASQLQuery.select(Expression<U> expr)

Uses of Expression in com.querydsl.lucene3

Classes in com.querydsl.lucene3 that implement Expression

Modifier and Type	Class and Description
class	PhraseElement PhraseElement represents the embedded String as a phrase
class	QueryElement QueryElement wraps a Lucene Query
class	TermElement TermElement represents the embedded String as a term

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

Modifier and Type	Method and Description
protected String[]	LuceneSerializer.convert(Path<?> leftHandSide, Expression<?> rightHandSide, QueryMetadata metadata) template method
protected org.apache.lucene.search.Query	LuceneSerializer.range(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
protected org.apache.lucene.search.Query	LuceneSerializer.range(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
protected org.apache.lucene.search.Query	LuceneSerializer.stringRange(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
protected org.apache.lucene.search.Query	LuceneSerializer.stringRange(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
org.apache.lucene.search.Query	LuceneSerializer.toQuery(Expression<?> expr, QueryMetadata metadata)

Uses of Expression in com.querydsl.lucene4

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

Modifier and Type	Method and Description
protected String[]	LuceneSerializer.convert(Path<?> leftHandSide, Expression<?> rightHandSide, QueryMetadata metadata) template method
protected org.apache.lucene.search.Query	LuceneSerializer.range(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
protected org.apache.lucene.search.Query	LuceneSerializer.range(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
protected org.apache.lucene.search.Query	LuceneSerializer.stringRange(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
protected org.apache.lucene.search.Query	LuceneSerializer.stringRange(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
org.apache.lucene.search.Query	LuceneSerializer.toQuery(Expression<?> expr, QueryMetadata metadata)

Uses of Expression in com.querydsl.lucene5

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

Modifier and Type	Method and Description
protected String[]	LuceneSerializer.convert(Path<?> leftHandSide, Expression<?> rightHandSide, QueryMetadata metadata) template method
protected org.apache.lucene.search.Query	LuceneSerializer.range(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
protected org.apache.lucene.search.Query	LuceneSerializer.range(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
protected org.apache.lucene.search.Query	LuceneSerializer.stringRange(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
protected org.apache.lucene.search.Query	LuceneSerializer.stringRange(Path<?> leftHandSide, String field, Expression<?> min, Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata)
org.apache.lucene.search.Query	LuceneSerializer.toQuery(Expression<?> expr, QueryMetadata metadata)

Uses of Expression in com.querydsl.mongodb

Classes in com.querydsl.mongodb that implement Expression

Modifier and Type	Class and Description
class	Point Point is an adapter type for Double[] arrays to use geo spatial querying features of Mongodb

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

Modifier and Type	Method and Description
protected com.mongodb.DBCursor	AbstractMongodbQuery.createCursor(com.mongodb.DBCollection collection, Predicate where, Expression<?> projection, QueryModifiers modifiers, List<OrderSpecifier<?>> orderBy)
Object	MongodbSerializer.handle(Expression<?> expression)
static BooleanExpression	MongodbExpressions.near(Expression<Double[]> expr, double latVal, double longVal) Finds the closest points relative to the given location and orders the results with decreasing proximity
static BooleanExpression	MongodbExpressions.nearSphere(Expression<Double[]> expr, double latVal, double longVal) Finds the closest points relative to the given location on a sphere and orders the results with decreasing proximity

Uses of Expression in com.querydsl.spatial

Classes in com.querydsl.spatial that implement Expression

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

Methods in com.querydsl.spatial that return Expression

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

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

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

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

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

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

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

Constructor parameters in com.querydsl.spatial with type arguments of type Expression

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

Uses of Expression in com.querydsl.spatial.jts

Classes in com.querydsl.spatial.jts that implement Expression

Modifier and Type	Class and Description
class	JTSCurveExpression<T extends com.vividsolutions.jts.geom.Geometry> A Curve is a 1-dimensional geometric object usually stored as a sequence of Points, with the subtype of Curve specifying the form of the interpolation between Points.
class	JTSGeometryCollectionExpression<T extends com.vividsolutions.jts.geom.GeometryCollection> A Geometry collection is a geometric object that is a collection of some number of geometric objects.
class	JTSGeometryCollectionPath<T extends com.vividsolutions.jts.geom.GeometryCollection> JTSGeometryCollectionPath extends JTSGeometryCollectionExpression to implement the Path interface
class	JTSGeometryExpression<T extends com.vividsolutions.jts.geom.Geometry> Geometry is the root class of the hierarchy.
class	JTSGeometryOperation<T extends com.vividsolutions.jts.geom.Geometry> JTSGeometryOperation extends JTSGeometryExpression to implement the Operation interface
class	JTSGeometryPath<T extends com.vividsolutions.jts.geom.Geometry> JTSGeometryPath extends JTSGeometryExpression to implement the Path interface
class	JTSLinearRingExpression<T extends com.vividsolutions.jts.geom.LineString> A LinearRing is a LineString that is both closed and simple.
class	JTSLinearRingPath<T extends com.vividsolutions.jts.geom.LinearRing> JTSLinearRingPath extends JTSLinearRingExpression to implement the Path interface
class	JTSLineExpression<T extends com.vividsolutions.jts.geom.LineString> A Line is a LineString with exactly 2 Points.
class	JTSLineStringExpression<T extends com.vividsolutions.jts.geom.LineString> A LineString is a Curve with linear interpolation between Points.
class	JTSLineStringOperation<T extends com.vividsolutions.jts.geom.LineString> JTSLineStringOperation extends JTSLineStringExpression to implement the Operation interface
class	JTSLineStringPath<T extends com.vividsolutions.jts.geom.LineString> JTSLineStringPath extends JTSLineStringExpression to implement the Path interface
class	JTSMultiCurveExpression<T extends com.vividsolutions.jts.geom.GeometryCollection> A MultiCurve is a 1-dimensional GeometryCollection whose elements are Curves.
class	JTSMultiLineStringExpression<T extends com.vividsolutions.jts.geom.MultiLineString> A MultiLineString is a MultiCurve whose elements are LineStrings.
class	JTSMultiLineStringPath<T extends com.vividsolutions.jts.geom.MultiLineString> JTSMultiLineStringPath extends JTSMultiLineStringExpression to implement the Path interface
class	JTSMultiPointExpression<T extends com.vividsolutions.jts.geom.MultiPoint> A MultiPoint is a 0-dimensional GeometryCollection.
class	JTSMultiPointPath<T extends com.vividsolutions.jts.geom.MultiPoint> JTSMultiPointPath extends JTSMultiPointExpression to implement the Path interface
class	JTSMultiPolygonExpression<T extends com.vividsolutions.jts.geom.MultiPolygon> A MultiPolygon is a MultiSurface whose elements are Polygons.
class	JTSMultiPolygonPath<T extends com.vividsolutions.jts.geom.MultiPolygon> JTSMultiPolygonPath extends JTSMultiPolygonExpression to implement the Path interface
class	JTSMultiSurfaceExpression<T extends com.vividsolutions.jts.geom.GeometryCollection> A MultiSurface is a 2-dimensional GeometryCollection whose elements are Surfaces, all using coordinates from the same coordinate reference system.
class	JTSPointExpression<T extends com.vividsolutions.jts.geom.Point> A Point is a 0-dimensional geometric object and represents a single location in coordinate space.
class	JTSPointOperation<T extends com.vividsolutions.jts.geom.Point> JTSPointOperation extends JTSPointExpression to implement the Operation interface
class	JTSPointPath<T extends com.vividsolutions.jts.geom.Point> JTSPointPath extends JTSPointExpression to implement the Path interface
class	JTSPolygonExpression<T extends com.vividsolutions.jts.geom.Polygon> A Polygon is a planar Surface defined by 1 exterior boundary and 0 or more interior boundaries.
class	JTSPolygonOperation<T extends com.vividsolutions.jts.geom.Polygon> JTSPolygonOperation extends JTSPolygonExpression to implement the Operation interface
class	JTSPolygonPath<T extends com.vividsolutions.jts.geom.Polygon> JTSPolygonPath extends JTSPolygonExpression to implement the Path interface
class	JTSSurfaceExpression<T extends com.vividsolutions.jts.geom.Geometry> A Surface is a 2-dimensional geometric object.

Methods in com.querydsl.spatial.jts that return Expression

Modifier and Type	Method and Description
Expression<?>	JTSPolygonOperation.getArg(int index)
Expression<?>	JTSPointOperation.getArg(int index)
Expression<?>	JTSLineStringOperation.getArg(int index)
Expression<?>	JTSGeometryOperation.getArg(int index)

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

Modifier and Type	Method and Description
List<Expression<?>>	JTSPolygonOperation.getArgs()
List<Expression<?>>	JTSPointOperation.getArgs()
List<Expression<?>>	JTSLineStringOperation.getArgs()
List<Expression<?>>	JTSGeometryOperation.getArgs()

Methods in com.querydsl.spatial.jts with parameters of type Expression

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

Constructors in com.querydsl.spatial.jts with parameters of type Expression

Constructor and Description
JTSCurveExpression(Expression<T> mixin)
JTSGeometryCollectionExpression(Expression<T> mixin)
JTSGeometryExpression(Expression<T> mixin)
JTSGeometryOperation(Class<? extends T> type, Operator op, Expression<?>... args)
JTSLinearRingExpression(Expression<T> mixin)
JTSLineExpression(Expression<T> mixin)
JTSLineStringExpression(Expression<T> mixin)
JTSLineStringOperation(Class<? extends T> type, Operator op, Expression<?>... args)
JTSMultiCurveExpression(Expression<T> mixin)
JTSMultiLineStringExpression(Expression<T> mixin)
JTSMultiPointExpression(Expression<T> mixin)
JTSMultiPolygonExpression(Expression<T> mixin)
JTSMultiSurfaceExpression(Expression<T> mixin)
JTSPointExpression(Expression<T> mixin)
JTSPointOperation(Class<T> type, Operator op, Expression<?>... args)
JTSPolygonExpression(Expression<T> mixin)
JTSPolygonOperation(Class<? extends T> type, Operator op, Expression<?>... args)
JTSSurfaceExpression(Expression<T> mixin)

Constructor parameters in com.querydsl.spatial.jts with type arguments of type Expression

Constructor and Description
JTSGeometryOperation(Class<? extends T> type, Operator op, com.google.common.collect.ImmutableList<Expression<?>> args)
JTSLineStringOperation(Class<? extends T> type, Operator op, com.google.common.collect.ImmutableList<Expression<?>> args)
JTSPointOperation(Class<T> type, Operator op, com.google.common.collect.ImmutableList<Expression<?>> args)
JTSPolygonOperation(Class<? extends T> type, Operator op, com.google.common.collect.ImmutableList<Expression<?>> args)

Uses of Expression in com.querydsl.sql

Subinterfaces of Expression in com.querydsl.sql

Modifier and Type	Interface and Description
interface	RelationalPath<T> RelationalPath extends EntityPath to provide access to relational metadata
interface	Union<RT> Union defines an interface for Union queries

Classes in com.querydsl.sql that implement Expression

Modifier and Type	Class and Description
class	AbstractSQLQuery<T,Q extends AbstractSQLQuery<T,Q>> AbstractSQLQuery is the base type for SQL query implementations
class	ProjectableSQLQuery<T,Q extends ProjectableSQLQuery<T,Q> & Query<Q>> ProjectableSQLQuery is the base type for SQL query implementations
class	QBeans Expression used to project a list of beans
class	RelationalFunctionCall<T> Represents a table valued function call
class	RelationalPathBase<T> RelationalPathBase is a base class for RelationalPath implementations
class	SQLQuery<T> SQLQuery is a JDBC based implementation of the SQLCommonQuery interface
class	UnionImpl<T,Q extends ProjectableSQLQuery<T,Q> & Query<Q>> Default implementation of the Union interface
class	WindowFirstLast<T> WindowFirstLast is a builder for window function expressions
class	WindowFunction<A> WindowFunction is a builder for window function expressions
class	WindowOver<T> WindowOver is the first part of a WindowFunction construction
class	WithinGroup<T> WithinGroup is a builder for WITHIN GROUP constructs
class	WithinGroup.OrderBy Intermediate step

Fields in com.querydsl.sql declared as Expression

Modifier and Type	Field and Description
static Expression<Object[]>	SQLExpressions.all Wildcard expression
static Expression<Long>	SQLExpressions.countAll Wildcard count expression
protected static Expression<?>	SQLTemplates.FOR_SHARE
protected static Expression<?>	SQLTemplates.FOR_UPDATE
protected static Expression<?>	MySQLTemplates.LOCK_IN_SHARE_MODE
protected static Expression<?>	SQLTemplates.NO_WAIT
static Expression<?>	SQLTemplates.RECURSIVE
protected Expression<?>	ProjectableSQLQuery.union
protected static Expression<?>	SQLServerTemplates.WITH_REPEATABLE_READ

Methods in com.querydsl.sql that return Expression

Modifier and Type	Method and Description
Expression<RT>	Union.as(Path<RT> alias) Create an alias for the expression
Expression<T>	UnionImpl.as(Path<T> alias)
Expression<T>	UnionImpl.as(String alias)
Expression<RT>	Union.as(String alias) Create an alias for the expression
Expression<Tuple>	PrimaryKey.getProjection()
Expression<Tuple>	ForeignKey.getProjection()
static <T> Expression<T>	SQLExpressions.set(Path<T> target, Expression<? extends T> value) Create an assignment expression
static <T> Expression<T>	SQLExpressions.set(Path<T> target, T value) Create an assignment expression

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

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

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

Modifier and Type	Method and Description
Q	SQLCommonQuery.addFlag(QueryFlag.Position position, Expression<?> flag) Add the given Expression as a query flag
Q	ProjectableSQLQuery.addFlag(QueryFlag.Position position, Expression<?> flag) Add the given Expression as a query flag
Q	SQLCommonQuery.addFlag(QueryFlag.Position position, String prefix, Expression<?> expr) Add the given prefix and expression as a general query flag
Q	ProjectableSQLQuery.addFlag(QueryFlag.Position position, String prefix, Expression<?> expr) Add the given prefix and expression as a general query flag
R	WithBuilder.as(Expression<?> expr)
SimpleExpression<A>	WindowFunction.as(Expression<A> alias)
static <T extends Number> WindowOver<T>	SQLExpressions.avg(Expression<T> expr) Start a window function expression
static WindowOver<Double>	SQLExpressions.corr(Expression<? extends Number> expr1, Expression<? extends Number> expr2) CORR returns the coefficient of correlation of a set of number pairs.
static WindowOver<Double>	SQLExpressions.corr(Expression<? extends Number> expr1, Expression<? extends Number> expr2) CORR returns the coefficient of correlation of a set of number pairs.
static WindowOver<Long>	SQLExpressions.count(Expression<?> expr) Start a window function expression
static WindowOver<Long>	SQLExpressions.countDistinct(Expression<?> expr) Start a window function expression
static WindowOver<Double>	SQLExpressions.covarPop(Expression<? extends Number> expr1, Expression<? extends Number> expr2) CORR returns the coefficient of correlation of a set of number pairs.
static WindowOver<Double>	SQLExpressions.covarPop(Expression<? extends Number> expr1, Expression<? extends Number> expr2) CORR returns the coefficient of correlation of a set of number pairs.
static WindowOver<Double>	SQLExpressions.covarSamp(Expression<? extends Number> expr1, Expression<? extends Number> expr2) CORR returns the coefficient of correlation of a set of number pairs.
static WindowOver<Double>	SQLExpressions.covarSamp(Expression<? extends Number> expr1, Expression<? extends Number> expr2) CORR returns the coefficient of correlation of a set of number pairs.
static WithinGroup<Double>	SQLExpressions.cumeDist(Expression<?>... args) As an aggregate function, CUME_DIST calculates, for a hypothetical row r identified by the arguments of the function and a corresponding sort specification, the relative position of row r among the rows in the aggregation group.
static WithinGroup<Long>	SQLExpressions.denseRank(Expression<?>... args) As an aggregate function, DENSE_RANK calculates the dense rank of a hypothetical row identified by the arguments of the function with respect to a given sort specification.
BooleanExpression	RelationalPathBase.eq(Expression<? super T> right) Compares the two relational paths using primary key columns
BooleanExpression	WindowFunction.eq(Expression<A> expr)
static Set<RelationalPath<?>>	RelationalPathExtractor.extract(Expression<?> expr)
static <T> WindowOver<T>	SQLExpressions.firstValue(Expression<T> expr) returns value evaluated at the row that is the first row of the window frame
WindowRows.BetweenAnd	WindowRows.Between.following(Expression<Integer> expr)
WindowFunction<A>	WindowRows.BetweenAnd.following(Expression<Integer> expr)
Q	SQLCommonQueryFactory.from(Expression<?>... from) Create a new SELECT query
Q	SQLCommonQuery.from(Expression<?>... o) Defines the sources of the query
Q	ProjectableSQLQuery.from(Expression<?>... args)
Q	AbstractSQLQueryFactory.from(Expression<?>... args)
Q	SQLCommonQueryFactory.from(Expression<?> from) Create a new SELECT query
Q	ProjectableSQLQuery.from(Expression<?> arg)
Q	AbstractSQLQueryFactory.from(Expression<?> from)
ResultSet	AbstractSQLQuery.getResults(Expression<?>... exprs) Deprecated. Use @{code select(..)} to define the projection and getResults() to obtain the result set
Union<T>	UnionImpl.groupBy(Expression<?>... o)
Union<RT>	Union.groupBy(Expression<?>... o) Defines the grouping/aggregation expressions
static StringExpression	SQLExpressions.groupConcat(Expression<String> expr) Get a group_concat(expr) expression
static StringExpression	SQLExpressions.groupConcat(Expression<String> expr, String separator) Get a group_concat(expr, separator) expression
static <T> WindowOver<T>	SQLExpressions.lag(Expression<T> expr) expr evaluated at the row that is one row before the current row within the partition
static <T> WindowOver<T>	SQLExpressions.lastValue(Expression<T> expr) returns value evaluated at the row that is the last row of the window frame
static <T> WindowOver<T>	SQLExpressions.lead(Expression<T> expr) expr evaluated at the row that is one row after the current row within the partition;
static StringExpression	SQLExpressions.left(Expression<String> lhs, Expression<Integer> rhs) Get the rhs leftmost characters of lhs
static StringExpression	SQLExpressions.left(Expression<String> lhs, Expression<Integer> rhs) Get the rhs leftmost characters of lhs
static StringExpression	SQLExpressions.left(Expression<String> lhs, int rhs) Get the rhs leftmost characters of lhs
static WithinGroup<Object>	SQLExpressions.listagg(Expression<?> expr, String delimiter) LISTAGG orders data within each group specified in the ORDER BY clause and then concatenates the values of the measure column.
static <T extends Comparable> WindowOver<T>	SQLExpressions.max(Expression<T> expr) Start a window function expression
static <T extends Comparable> WindowOver<T>	SQLExpressions.min(Expression<T> expr) Start a window function expression
BooleanExpression	RelationalPathBase.ne(Expression<? super T> right) Compares the two relational paths using primary key columns
BooleanExpression	WindowFunction.ne(Expression<A> expr)
static <T> WindowOver<T>	SQLExpressions.nthValue(Expression<T> expr, Expression<? extends Number> n) NTH_VALUE returns the expr value of the nth row in the window defined by the analytic clause.
static <T> WindowOver<T>	SQLExpressions.nthValue(Expression<T> expr, Expression<? extends Number> n) NTH_VALUE returns the expr value of the nth row in the window defined by the analytic clause.
static <T> WindowOver<T>	SQLExpressions.nthValue(Expression<T> expr, Number n) NTH_VALUE returns the expr value of the nth row in the window defined by the analytic clause.
WindowFunction<A>	WindowFunction.partitionBy(Expression<?>... partitionBy)
WindowFunction<A>	WindowFunction.partitionBy(Expression<?> partitionBy)
static <T extends Number> WithinGroup<T>	SQLExpressions.percentileCont(Expression<T> arg) Calculates a percentile based on a continuous distribution of the column value
static <T extends Number> WithinGroup<T>	SQLExpressions.percentileDisc(Expression<T> arg) PERCENTILE_DISC is an inverse distribution function that assumes a discrete distribution model.
static WithinGroup<Double>	SQLExpressions.percentRank(Expression<?>... args) As an aggregate function, PERCENT_RANK calculates, for a hypothetical row r identified by the arguments of the function and a corresponding sort specification, the rank of row r minus 1 divided by the number of rows in the aggregate group.
WindowFunction<A>	WindowRows.preceding(Expression<Integer> expr)
WindowRows.BetweenAnd	WindowRows.Between.preceding(Expression<Integer> expr)
WindowFunction<A>	WindowRows.BetweenAnd.preceding(Expression<Integer> expr)
static WithinGroup<Long>	SQLExpressions.rank(Expression<?>... args) As an aggregate function, RANK calculates the rank of a hypothetical row identified by the arguments of the function with respect to a given sort specification.
static <T> WindowOver<T>	SQLExpressions.ratioToReport(Expression<T> expr) computes the ratio of a value to the sum of a set of values.
static WindowOver<Double>	SQLExpressions.regrAvgx(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_AVGX evaluates the average of the independent variable (arg2) of the regression line.
static WindowOver<Double>	SQLExpressions.regrAvgx(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_AVGX evaluates the average of the independent variable (arg2) of the regression line.
static WindowOver<Double>	SQLExpressions.regrAvgy(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_AVGY evaluates the average of the dependent variable (arg1) of the regression line.
static WindowOver<Double>	SQLExpressions.regrAvgy(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_AVGY evaluates the average of the dependent variable (arg1) of the regression line.
static WindowOver<Double>	SQLExpressions.regrCount(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_COUNT returns an integer that is the number of non-null number pairs used to fit the regression line.
static WindowOver<Double>	SQLExpressions.regrCount(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_COUNT returns an integer that is the number of non-null number pairs used to fit the regression line.
static WindowOver<Double>	SQLExpressions.regrIntercept(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_INTERCEPT returns the y-intercept of the regression line.
static WindowOver<Double>	SQLExpressions.regrIntercept(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_INTERCEPT returns the y-intercept of the regression line.
static WindowOver<Double>	SQLExpressions.regrR2(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_R2 returns the coefficient of determination (also called R-squared or goodness of fit) for the regression.
static WindowOver<Double>	SQLExpressions.regrR2(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_R2 returns the coefficient of determination (also called R-squared or goodness of fit) for the regression.
static WindowOver<Double>	SQLExpressions.regrSlope(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_SLOPE returns the slope of the line
static WindowOver<Double>	SQLExpressions.regrSlope(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_SLOPE returns the slope of the line
static WindowOver<Double>	SQLExpressions.regrSxx(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_SXX makes the following computation after the elimination of null (arg1, arg2) pairs:
static WindowOver<Double>	SQLExpressions.regrSxx(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_SXX makes the following computation after the elimination of null (arg1, arg2) pairs:
static WindowOver<Double>	SQLExpressions.regrSxy(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_SXY makes the following computation after the elimination of null (arg1, arg2) pairs:
static WindowOver<Double>	SQLExpressions.regrSxy(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_SXY makes the following computation after the elimination of null (arg1, arg2) pairs:
static WindowOver<Double>	SQLExpressions.regrSyy(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_SYY makes the following computation after the elimination of null (arg1, arg2) pairs:
static WindowOver<Double>	SQLExpressions.regrSyy(Expression<? extends Number> arg1, Expression<? extends Number> arg2) REGR_SYY makes the following computation after the elimination of null (arg1, arg2) pairs:
static StringExpression	SQLExpressions.right(Expression<String> lhs, Expression<Integer> rhs) Get the rhs leftmost characters of lhs
static StringExpression	SQLExpressions.right(Expression<String> lhs, Expression<Integer> rhs) Get the rhs leftmost characters of lhs
static StringExpression	SQLExpressions.right(Expression<String> lhs, int rhs) Get the rhs rightmost characters of lhs
SQLQuery<Tuple>	SQLQueryFactory.select(Expression<?>... exprs)
SQLQuery<Tuple>	SQLQuery.select(Expression<?>... exprs)
static SQLQuery<Tuple>	SQLExpressions.select(Expression<?>... exprs) Create a new detached SQLQuery instance with the given projection
abstract AbstractSQLQuery<Tuple,?>	AbstractSQLQueryFactory.select(Expression<?>... exprs) Create a new SQL query with the given projection
<T> SQLQuery<T>	SQLQueryFactory.select(Expression<T> expr)
static <T> SQLQuery<T>	SQLExpressions.select(Expression<T> expr) Create a new detached SQLQuery instance with the given projection
abstract <T> AbstractSQLQuery<T,?>	AbstractSQLQueryFactory.select(Expression<T> expr) Create a new SQL query with the given projection
<U> SQLQuery<U>	SQLQuery.select(Expression<U> expr)
SQLQuery<Tuple>	SQLQueryFactory.selectDistinct(Expression<?>... exprs)
static SQLQuery<Tuple>	SQLExpressions.selectDistinct(Expression<?>... exprs) Create a new detached SQLQuery instance with the given projection
abstract AbstractSQLQuery<Tuple,?>	AbstractSQLQueryFactory.selectDistinct(Expression<?>... exprs) Create a new SQL query with the given projection
<T> SQLQuery<T>	SQLQueryFactory.selectDistinct(Expression<T> expr)
static <T> SQLQuery<T>	SQLExpressions.selectDistinct(Expression<T> expr) Create a new detached SQLQuery instance with the given projection
abstract <T> AbstractSQLQuery<T,?>	AbstractSQLQueryFactory.selectDistinct(Expression<T> expr) Create a new SQL query with the given projection
void	SQLSerializer.serializeUnion(Expression<?> union, QueryMetadata metadata, boolean unionAll)
static <T> Expression<T>	SQLExpressions.set(Path<T> target, Expression<? extends T> value) Create an assignment expression
static <T extends Number> WindowOver<T>	SQLExpressions.stddev(Expression<T> expr) returns the sample standard deviation of expr, a set of numbers.
static <T extends Number> WindowOver<T>	SQLExpressions.stddevDistinct(Expression<T> expr) returns the sample standard deviation of expr, a set of numbers.
static <T extends Number> WindowOver<T>	SQLExpressions.stddevPop(Expression<T> expr) returns the population standard deviation and returns the square root of the population variance.
static <T extends Number> WindowOver<T>	SQLExpressions.stddevSamp(Expression<T> expr) returns the cumulative sample standard deviation and returns the square root of the sample variance.
static <T extends Number> WindowOver<T>	SQLExpressions.sum(Expression<T> expr) Start a window function expression
static <T extends Number> WindowOver<T>	SQLExpressions.variance(Expression<T> expr) returns the variance of expr
static <T extends Number> WindowOver<T>	SQLExpressions.varPop(Expression<T> expr) returns the population variance of a set of numbers after discarding the nulls in this set.
static <T extends Number> WindowOver<T>	SQLExpressions.varSamp(Expression<T> expr) returns the sample variance of a set of numbers after discarding the nulls in this set.
Q	SQLCommonQuery.with(Path<?> alias, Expression<?> query) Adds a common table expression
Q	ProjectableSQLQuery.with(Path<?> alias, Expression<?> query)
Q	SQLCommonQuery.withRecursive(Path<?> alias, Expression<?> query) Adds a common table expression
Q	ProjectableSQLQuery.withRecursive(Path<?> alias, Expression<?> query)

Method parameters in com.querydsl.sql with type arguments of type Expression

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

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

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

Uses of Expression in com.querydsl.sql.dml

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

Modifier and Type	Method and Description
Map<Path<?>,Expression<?>>	SQLUpdateBatch.getUpdates()
List<Expression<?>>	SQLMergeBatch.getValues()
List<Expression<?>>	SQLInsertBatch.getValues()

Methods in com.querydsl.sql.dml with parameters of type Expression

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

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

Constructor and Description
SQLInsertBatch(List<Path<?>> c, List<Expression<?>> v, SubQueryExpression<?> sq)
SQLMergeBatch(List<Path<?>> k, List<Path<?>> c, List<Expression<?>> v, SubQueryExpression<?> sq)
SQLUpdateBatch(QueryMetadata metadata, Map<Path<?>,Expression<?>> updates)

Uses of Expression in com.querydsl.sql.mssql

Classes in com.querydsl.sql.mssql that implement Expression

Modifier and Type	Class and Description
class	SQLServerQuery<T> SQLServerQuery provides SQL Server related extensions to SQLQuery

Methods in com.querydsl.sql.mssql with parameters of type Expression

Modifier and Type	Method and Description
SQLServerQuery<Tuple>	SQLServerQueryFactory.select(Expression<?>... exprs)
SQLServerQuery<Tuple>	SQLServerQuery.select(Expression<?>... exprs)
<T> SQLServerQuery<T>	SQLServerQueryFactory.select(Expression<T> expr)
<U> SQLServerQuery<U>	SQLServerQuery.select(Expression<U> expr)
SQLServerQuery<Tuple>	SQLServerQueryFactory.selectDistinct(Expression<?>... exprs)
<T> SQLServerQuery<T>	SQLServerQueryFactory.selectDistinct(Expression<T> expr)

Uses of Expression in com.querydsl.sql.mysql

Classes in com.querydsl.sql.mysql that implement Expression

Modifier and Type	Class and Description
class	MySQLQuery<T> MySQLQuery provides MySQL related extensions to SQLQuery

Methods in com.querydsl.sql.mysql with parameters of type Expression

Modifier and Type	Method and Description
SQLInsertClause	MySQLQueryFactory.insertOnDuplicateKeyUpdate(RelationalPath<?> entity, Expression<?>... clauses) Create a INSERT ...
SQLInsertClause	MySQLQueryFactory.insertOnDuplicateKeyUpdate(RelationalPath<?> entity, Expression<?> clause) Create a INSERT ...
MySQLQuery<Tuple>	MySQLQueryFactory.select(Expression<?>... exprs)
MySQLQuery<Tuple>	MySQLQuery.select(Expression<?>... exprs)
<T> MySQLQuery<T>	MySQLQueryFactory.select(Expression<T> expr)
<U> MySQLQuery<U>	MySQLQuery.select(Expression<U> expr)
MySQLQuery<Tuple>	MySQLQueryFactory.selectDistinct(Expression<?>... exprs)
<T> MySQLQuery<T>	MySQLQueryFactory.selectDistinct(Expression<T> expr)

Uses of Expression in com.querydsl.sql.oracle

Classes in com.querydsl.sql.oracle that implement Expression

Modifier and Type	Class and Description
class	OracleQuery<T> OracleQuery provides Oracle specific extensions to the base SQL query type

Methods in com.querydsl.sql.oracle with parameters of type Expression

Modifier and Type	Method and Description
OracleQuery<T>	OracleQuery.orderSiblingsBy(Expression<?> path) ORDER SIBLINGS BY preserves any ordering specified in the hierarchical query clause and then applies the order_by_clause to the siblings of the hierarchy.
OracleQuery<Tuple>	OracleQueryFactory.select(Expression<?>... exprs)
OracleQuery<Tuple>	OracleQuery.select(Expression<?>... exprs)
<T> OracleQuery<T>	OracleQueryFactory.select(Expression<T> expr)
<U> OracleQuery<U>	OracleQuery.select(Expression<U> expr)
OracleQuery<Tuple>	OracleQueryFactory.selectDistinct(Expression<?>... exprs)
<T> OracleQuery<T>	OracleQueryFactory.selectDistinct(Expression<T> expr)

Uses of Expression in com.querydsl.sql.postgresql

Classes in com.querydsl.sql.postgresql that implement Expression

Modifier and Type	Class and Description
class	PostgreSQLQuery<T> PostgreSQLQuery provides PostgreSQL related extensions to SQLQuery

Methods in com.querydsl.sql.postgresql with parameters of type Expression

Modifier and Type	Method and Description
PostgreSQLQuery<T>	PostgreSQLQuery.distinctOn(Expression<?>... exprs) adds a DISTINCT ON clause
PostgreSQLQuery<Tuple>	PostgreSQLQueryFactory.select(Expression<?>... exprs)
PostgreSQLQuery<Tuple>	PostgreSQLQuery.select(Expression<?>... exprs)
<T> PostgreSQLQuery<T>	PostgreSQLQueryFactory.select(Expression<T> expr)
<U> PostgreSQLQuery<U>	PostgreSQLQuery.select(Expression<U> expr)
PostgreSQLQuery<Tuple>	PostgreSQLQueryFactory.selectDistinct(Expression<?>... exprs)
<T> PostgreSQLQuery<T>	PostgreSQLQueryFactory.selectDistinct(Expression<T> expr)

Uses of Expression in com.querydsl.sql.spatial

Classes in com.querydsl.sql.spatial that implement Expression

Modifier and Type	Class and Description
class	QSpatialRefSys QSpatialRefSys is a Querydsl query type for SpatialRefSys
class	RelationalPathSpatial<T> RelationalPathSpatial extends RelationalPathBase to provide factory methods for spatial path creation

Uses of Expression in com.querydsl.sql.teradata

Classes in com.querydsl.sql.teradata that implement Expression

Modifier and Type	Class and Description
class	TeradataQuery<T> TeradataQuery provides Teradata related extensions to SQLQuery

Methods in com.querydsl.sql.teradata with parameters of type Expression

Modifier and Type	Method and Description
TeradataQuery<Tuple>	TeradataQueryFactory.select(Expression<?>... exprs)
TeradataQuery<Tuple>	TeradataQuery.select(Expression<?>... exprs)
<T> TeradataQuery<T>	TeradataQueryFactory.select(Expression<T> expr)
<U> TeradataQuery<U>	TeradataQuery.select(Expression<U> expr)
TeradataQuery<Tuple>	TeradataQueryFactory.selectDistinct(Expression<?>... exprs)
<T> TeradataQuery<T>	TeradataQueryFactory.selectDistinct(Expression<T> expr)