Uses of Class
com.mysema.query.types.expr.Expr

Packages that use Expr

com.mysema.query	Contains basic Query elements
com.mysema.query.alias	Alias functionality
com.mysema.query.collections.impl	Implementations of Querydsl query interfaces for JavaBean collections
com.mysema.query.functions	Optional function libraries
com.mysema.query.hql	Query implementations for HQL and JPAQL
com.mysema.query.hql.hibernate	HQL for Hibernate
com.mysema.query.hql.jpa	HQL Support classes
com.mysema.query.jdoql	JDOQL support for Querydsl
com.mysema.query.serialization	Contains stubs for Serialization of queries
com.mysema.query.sql	SQL/JDBC support for Querydsl
com.mysema.query.sql.oracle	Oracle support for Querydsl SQL
com.mysema.query.support	Various support classes
com.mysema.query.types	Contains Querydsl grammar types
com.mysema.query.types.custom	Custom types are comparable to operations but contain the serialization templates instead of operator patterns.
com.mysema.query.types.expr	Expr encode the base type hierarchy and signatures of Querydsl expressions
com.mysema.query.types.operation	Operations represent typed operations with operator and arguments
com.mysema.query.types.path	Paths represent typed property paths, variables and list-map-array access
com.mysema.query.types.query	Subquery implementations

Uses of Expr in com.mysema.query

Subclasses of Expr in com.mysema.query

class

BooleanBuilder BooleanBuilder is a cascading builder for Boolean expressions.

Methods in com.mysema.query that return Expr

Expr<?>

JoinExpression.getTarget()

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

List<? extends Expr<?>>	QueryMetadata.getGroupBy()
List<? extends Expr<?>>	DefaultQueryMetadata.getGroupBy()
List<? extends Expr<?>>	QueryMetadata.getProjection()
List<? extends Expr<?>>	DefaultQueryMetadata.getProjection()

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

void	QueryMetadata.addFrom(Expr<?>... o)
void	DefaultQueryMetadata.addFrom(Expr<?>... args)
void	QueryMetadata.addGroupBy(Expr<?>... o)
void	DefaultQueryMetadata.addGroupBy(Expr<?>... o)
void	QueryMetadata.addJoin(JoinType joinType, Expr<?> expr)
void	DefaultQueryMetadata.addJoin(JoinType joinType, Expr<?> expr)
void	QueryMetadata.addProjection(Expr<?>... o)
void	DefaultQueryMetadata.addProjection(Expr<?>... o)
T	QueryMixin.addToProjection(Expr<?>... o)
T	QueryMixin.groupBy(Expr<?>... o)
SubType	QueryBase.groupBy(Expr<?>... o)
SubType	Query.groupBy(Expr<?>... o) Defines the grouping/aggregation expressions
Iterator<Object[]>	Projectable.iterate(Expr<?>[] args) iterate over the results for the given projection
Iterator<Object[]>	Projectable.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the results for the given projection
Iterator<Object[]>	Projectable.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the results for the given projection
Iterator<Object[]>	Projectable.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the results for the given projection
<RT> Iterator<RT>	Projectable.iterate(Expr<RT> projection) iterate over the results for the given projection
Iterator<Object[]>	Projectable.iterateDistinct(Expr<?>[] args) iterate over the distinct results for the given projection
Iterator<Object[]>	Projectable.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the distinct results for the given projection
Iterator<Object[]>	Projectable.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the distinct results for the given projection
Iterator<Object[]>	Projectable.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the distinct results for the given projection
<RT> Iterator<RT>	Projectable.iterateDistinct(Expr<RT> projection) iterate over the distinct results for the given projection
List<Object[]>	Projectable.list(Expr<?>[] args) list the results for the given projection
ListSubQuery<Object[]>	Detachable.list(Expr<?>[] args)
List<Object[]>	Projectable.list(Expr<?> first, Expr<?> second, Expr<?>... rest) list the results for the given projection
List<Object[]>	Projectable.list(Expr<?> first, Expr<?> second, Expr<?>... rest) list the results for the given projection
List<Object[]>	Projectable.list(Expr<?> first, Expr<?> second, Expr<?>... rest) list the results for the given projection
ListSubQuery<Object[]>	Detachable.list(Expr<?> first, Expr<?> second, Expr<?>... rest) Create a projection expression for the given projection
ListSubQuery<Object[]>	Detachable.list(Expr<?> first, Expr<?> second, Expr<?>... rest) Create a projection expression for the given projection
ListSubQuery<Object[]>	Detachable.list(Expr<?> first, Expr<?> second, Expr<?>... rest) Create a projection expression for the given projection
<RT> List<RT>	Projectable.list(Expr<RT> projection) list the results for the given projection
<RT> ListSubQuery<RT>	Detachable.list(Expr<RT> projection) Create a projection expression for the given projection
List<Object[]>	Projectable.listDistinct(Expr<?>[] args) list the distinct results for the given projection
List<Object[]>	Projectable.listDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest) list the distinct results for the given projection
List<Object[]>	Projectable.listDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest) list the distinct results for the given projection
List<Object[]>	Projectable.listDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest) list the distinct results for the given projection
<RT> List<RT>	Projectable.listDistinct(Expr<RT> projection) list the distinct results for the given projection
<RT> SearchResults<RT>	Projectable.listDistinctResults(Expr<RT> projection) list the distinct results for the given projection
<RT> SearchResults<RT>	Projectable.listResults(Expr<RT> projection) list the results for the given projection
<K,V> Map<K,V>	Projectable.map(Expr<K> key, Expr<V> value) return the given projection as a Map instance using key and value for Map population
<K,V> Map<K,V>	Projectable.map(Expr<K> key, Expr<V> value) return the given projection as a Map instance using key and value for Map population
ObjectSubQuery<Object[]>	Detachable.unique(Expr<?>[] args) Create a projection expression for the given projection
ObjectSubQuery<Object[]>	Detachable.unique(Expr<?> first, Expr<?> second, Expr<?>... rest) Create a projection expression for the given projection
ObjectSubQuery<Object[]>	Detachable.unique(Expr<?> first, Expr<?> second, Expr<?>... rest) Create a projection expression for the given projection
ObjectSubQuery<Object[]>	Detachable.unique(Expr<?> first, Expr<?> second, Expr<?>... rest) Create a projection expression for the given projection
<RT> ObjectSubQuery<RT>	Detachable.unique(Expr<RT> projection) Create a projection expression for the given projection
Object[]	Projectable.uniqueResult(Expr<?>[] args) return a unique result for the given projection
Object[]	Projectable.uniqueResult(Expr<?> first, Expr<?> second, Expr<?>... rest) return a unique result for the given projection
Object[]	Projectable.uniqueResult(Expr<?> first, Expr<?> second, Expr<?>... rest) return a unique result for the given projection
Object[]	Projectable.uniqueResult(Expr<?> first, Expr<?> second, Expr<?>... rest) return a unique result for the given projection
<RT> RT	Projectable.uniqueResult(Expr<RT> projection) return a unique result for the given projection

Constructors in com.mysema.query with parameters of type Expr

JoinExpression(JoinType type, Expr<?> target)

Uses of Expr in com.mysema.query.alias

Methods in com.mysema.query.alias with type parameters of type Expr

static <D extends Expr<?>> D

Alias.$() Convert the given alias to an expression

Methods in com.mysema.query.alias that return Expr

static <D> Expr<D>

Alias.getAny(D arg) Convert the given alias to an expression

Methods in com.mysema.query.alias with parameters of type Expr

static <A> A

Alias.alias(Class<A> cl, Expr<? extends A> expr)

Uses of Expr in com.mysema.query.collections.impl

Methods in com.mysema.query.collections.impl with parameters of type Expr

<T> Evaluator<T>	EvaluatorFactory.create(List<? extends Expr<?>> sources, Expr<T> projection)
protected <RT> Iterator<RT>	AbstractColQuery.handleSelect(Iterator<?> it, List<Expr<?>> sources, Expr<RT> projection)
Iterator<Object[]>	AbstractColQuery.iterate(Expr<?>[] args)
<RT> Iterator<RT>	AbstractColQuery.iterate(Expr<RT> projection)
<RT> SearchResults<RT>	AbstractColQuery.listResults(Expr<RT> projection)
<S,T> Iterator<T>	IteratorFactory.transform(Iterator<S> source, List<Expr<?>> sources, Expr<T> projection)

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

<T> Evaluator<T>	EvaluatorFactory.create(List<? extends Expr<?>> sources, Expr<T> projection)
protected Iterator<?>	AbstractColQuery.handleFromWhereMultiSource(List<Expr<?>> sources)
protected Iterator<?>	AbstractColQuery.handleFromWhereSingleSource(List<Expr<?>> sources)
protected Iterator<?>	AbstractColQuery.handleOrderBy(List<Expr<?>> sources, Iterator<?> it)
protected <RT> Iterator<RT>	AbstractColQuery.handleSelect(Iterator<?> it, List<Expr<?>> sources, Expr<RT> projection)
<S> Iterator<S>	IteratorFactory.multiArgFilter(Iterator<S> source, List<Expr<?>> sources, EBoolean condition)
<S,T> Iterator<T>	IteratorFactory.transform(Iterator<S> source, List<Expr<?>> sources, Expr<T> projection)
protected void	ColQuerySerializer.visitOperation(Class<?> type, Operator<?> operator, List<Expr<?>> args)

Uses of Expr in com.mysema.query.functions

Methods in com.mysema.query.functions with parameters of type Expr

static ENumber<Double>	MathFunctions.acos(Expr<Double> left)
static ENumber<Double>	MathFunctions.asin(Expr<Double> left)
static ENumber<Double>	MathFunctions.atan(Expr<Double> left)
static ENumber<Double>	MathFunctions.cos(Expr<Double> left)
static ENumber<Double>	MathFunctions.exp(Expr<Double> left)
static ENumber<Double>	MathFunctions.log(Expr<Double> left)
static ENumber<Double>	MathFunctions.log10(Expr<Double> left)
static ENumber<Double>	MathFunctions.pow(Expr<Double> left, Expr<Double> right)
static ENumber<Double>	MathFunctions.pow(Expr<Double> left, Expr<Double> right)
static ENumber<Double>	MathFunctions.sin(Expr<Double> left)
static ENumber<Double>	MathFunctions.tan(Expr<Double> left)

Uses of Expr in com.mysema.query.hql

Methods in com.mysema.query.hql that return Expr

static <D> Expr<D>	HQLGrammar.all(ECollection<?,D> col)
static <D> Expr<D>	HQLGrammar.any(ECollection<?,D> col)
static <D> Expr<D>	HQLGrammar.some(ECollection<?,D> col)

Methods in com.mysema.query.hql with parameters of type Expr

static <D extends Number & Comparable<? super D>> ENumber<?>	HQLGrammar.sum(Expr<D> left) SUM returns Long when applied to state-fields of integral types (other than BigInteger); Double when applied to state-fields of floating point types; BigInteger when applied to state-fields of type BigInteger; and BigDecimal when applied to state-fields of type BigDecimal.
static <D extends Number & Comparable<? super D>> ENumber<Double>	HQLGrammar.sumAsDouble(Expr<D> left)
static <D extends Number & Comparable<? super D>> ENumber<Long>	HQLGrammar.sumAsLong(Expr<D> left)

Method parameters in com.mysema.query.hql with type arguments of type Expr

protected void

HQLSerializer.visitOperation(Class<?> type, Operator<?> operator, List<Expr<?>> args)

Uses of Expr in com.mysema.query.hql.hibernate

Methods in com.mysema.query.hql.hibernate with parameters of type Expr

long	AbstractHibernateQuery.count(Expr<?> expr)
org.hibernate.Query	AbstractHibernateQuery.createQuery(Expr<?> expr) Expose the original Hibernate query for the given projection
org.hibernate.Query	AbstractHibernateQuery.createQuery(Expr<?>[] args) Expose the original Hibernate query for the given projection
org.hibernate.Query	AbstractHibernateQuery.createQuery(Expr<?> expr1, Expr<?> expr2, Expr<?>... rest) Expose the original Hibernate query for the given projection
org.hibernate.Query	AbstractHibernateQuery.createQuery(Expr<?> expr1, Expr<?> expr2, Expr<?>... rest) Expose the original Hibernate query for the given projection
org.hibernate.Query	AbstractHibernateQuery.createQuery(Expr<?> expr1, Expr<?> expr2, Expr<?>... rest) Expose the original Hibernate query for the given projection
Iterator<Object[]>	AbstractHibernateQuery.iterate(Expr<?>[] args) Return the query results as an Iterator.
<RT> Iterator<RT>	AbstractHibernateQuery.iterate(Expr<RT> projection) Return the query results as an Iterator.
List<Object[]>	AbstractHibernateQuery.list(Expr<?>[] args)
<RT> List<RT>	AbstractHibernateQuery.list(Expr<RT> expr)
<RT> SearchResults<RT>	AbstractHibernateQuery.listResults(Expr<RT> expr)
org.hibernate.ScrollableResults	AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode, Expr<?> expr) Return the query results as ScrollableResults.
org.hibernate.ScrollableResults	AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode, Expr<?>[] args) Return the query results as ScrollableResults.
org.hibernate.ScrollableResults	AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode, Expr<?> expr1, Expr<?> expr2, Expr<?>... rest) Return the query results as ScrollableResults.
org.hibernate.ScrollableResults	AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode, Expr<?> expr1, Expr<?> expr2, Expr<?>... rest) Return the query results as ScrollableResults.
org.hibernate.ScrollableResults	AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode, Expr<?> expr1, Expr<?> expr2, Expr<?>... rest) Return the query results as ScrollableResults.
<RT> RT	AbstractHibernateQuery.uniqueResult(Expr<RT> expr)

Uses of Expr in com.mysema.query.hql.jpa

Methods in com.mysema.query.hql.jpa with parameters of type Expr

javax.persistence.Query	AbstractJPAQuery.createQuery(Expr<?> expr) Expose the original JPA query for the given projection
javax.persistence.Query	AbstractJPAQuery.createQuery(Expr<?>[] args) Expose the original JPA query for the given projection
javax.persistence.Query	AbstractJPAQuery.createQuery(Expr<?> expr1, Expr<?> expr2, Expr<?>... rest) Expose the original JPA query for the given projection
javax.persistence.Query	AbstractJPAQuery.createQuery(Expr<?> expr1, Expr<?> expr2, Expr<?>... rest) Expose the original JPA query for the given projection
javax.persistence.Query	AbstractJPAQuery.createQuery(Expr<?> expr1, Expr<?> expr2, Expr<?>... rest) Expose the original JPA query for the given projection
Iterator<Object[]>	AbstractJPAQuery.iterate(Expr<?>[] args)
<RT> Iterator<RT>	AbstractJPAQuery.iterate(Expr<RT> projection)
List<Object[]>	AbstractJPAQuery.list(Expr<?>[] args)
<RT> List<RT>	AbstractJPAQuery.list(Expr<RT> expr)
<RT> SearchResults<RT>	AbstractJPAQuery.listResults(Expr<RT> expr)
<RT> RT	AbstractJPAQuery.uniqueResult(Expr<RT> expr)

Uses of Expr in com.mysema.query.jdoql

Methods in com.mysema.query.jdoql that return Expr

Expr<?>

JDOQLSerializer.getCandidatePath()

Methods in com.mysema.query.jdoql with parameters of type Expr

T	JDOQLQueryMixin.addToProjection(Expr<?>... o)
Iterator<Object[]>	AbstractJDOQLQuery.iterate(Expr<?>[] args)
<RT> Iterator<RT>	AbstractJDOQLQuery.iterate(Expr<RT> projection)
List<Object[]>	AbstractJDOQLQuery.list(Expr<?>[] args)
<RT> List<RT>	AbstractJDOQLQuery.list(Expr<RT> expr)
<RT> SearchResults<RT>	AbstractJDOQLQuery.listResults(Expr<RT> expr)
<RT> RT	AbstractJDOQLQuery.uniqueResult(Expr<RT> expr)

Method parameters in com.mysema.query.jdoql with type arguments of type Expr

protected void

JDOQLSerializer.visitOperation(Class<?> type, Operator<?> operator, List<Expr<?>> args)

Constructors in com.mysema.query.jdoql with parameters of type Expr

JDOQLSerializer(JDOQLTemplates patterns, Expr<?> candidate)

Uses of Expr in com.mysema.query.serialization

Method parameters in com.mysema.query.serialization with type arguments of type Expr

SubType	SerializerBase.handle(String sep, List<? extends Expr<?>> expressions)
protected void	SerializerBase.visitOperation(Class<?> type, Operator<?> operator, List<Expr<?>> args)

Uses of Expr in com.mysema.query.sql

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

Iterator<Object[]>	AbstractSQLQuery.iterate(Expr<?>[] args)
<RT> Iterator<RT>	AbstractSQLQuery.iterate(Expr<RT> projection)
List<Object[]>	AbstractSQLQuery.list(Expr<?>[] args)
<RT> List<RT>	AbstractSQLQuery.list(Expr<RT> expr)
<RT> SearchResults<RT>	AbstractSQLQuery.listResults(Expr<RT> expr)
<RT> RT	AbstractSQLQuery.uniqueResult(Expr<RT> expr)

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

protected void

SQLSerializer.visitOperation(Class<?> type, Operator<?> operator, List<Expr<?>> args)

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

Subclasses of Expr in com.mysema.query.sql.oracle

class

SumOver<A extends Number & Comparable<? super A>> SumOver is a fluent type for Oracle specific sum over / partition by / order by constructs

Methods in com.mysema.query.sql.oracle that return Expr

Expr<?>	SumOver.getPartitionBy()
Expr<A>	SumOver.getTarget()

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

List<Expr<?>>

SumOver.getOrderBy()

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

SumOver<A>	SumOver.order(Expr<?>... orderBy)
OracleQuery	OracleQuery.orderSiblingsBy(Expr<?> path)
SumOver<A>	SumOver.partition(Expr<?> partitionBy)
static <A extends Number & Comparable<? super A>> SumOver<A>	OracleGrammar.sumOver(Expr<A> expr)

Constructors in com.mysema.query.sql.oracle with parameters of type Expr

OracleSerializer(SQLTemplates patterns, EBoolean connectBy, EBoolean connectByNocyclePrior, EBoolean connectByPrior, Expr<?> orderSiblingsBy, EBoolean startWith)

SumOver(Expr<A> expr)

Uses of Expr in com.mysema.query.support

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

Iterator<Object[]>	ProjectableAdapter.iterate(Expr<?>[] args)
Iterator<Object[]>	ProjectableQuery.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
Iterator<Object[]>	ProjectableQuery.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
Iterator<Object[]>	ProjectableQuery.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
Iterator<Object[]>	ProjectableAdapter.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
Iterator<Object[]>	ProjectableAdapter.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
Iterator<Object[]>	ProjectableAdapter.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
<RT> Iterator<RT>	ProjectableAdapter.iterate(Expr<RT> projection)
Iterator<Object[]>	ProjectableQuery.iterateDistinct(Expr<?>[] args)
Iterator<Object[]>	ProjectableAdapter.iterateDistinct(Expr<?>[] args)
Iterator<Object[]>	ProjectableQuery.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
Iterator<Object[]>	ProjectableQuery.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
Iterator<Object[]>	ProjectableQuery.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
Iterator<Object[]>	ProjectableAdapter.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
Iterator<Object[]>	ProjectableAdapter.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
Iterator<Object[]>	ProjectableAdapter.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
<RT> Iterator<RT>	ProjectableQuery.iterateDistinct(Expr<RT> projection)
<RT> Iterator<RT>	ProjectableAdapter.iterateDistinct(Expr<RT> projection)
List<Object[]>	ProjectableQuery.list(Expr<?>[] args)
List<Object[]>	ProjectableAdapter.list(Expr<?>[] args)
ListSubQuery<Object[]>	DetachableQuery.list(Expr<?>[] args)
ListSubQuery<Object[]>	DetachableMixin.list(Expr<?>[] args)
ListSubQuery<Object[]>	DetachableAdapter.list(Expr<?>[] args)
List<Object[]>	ProjectableQuery.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
List<Object[]>	ProjectableQuery.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
List<Object[]>	ProjectableQuery.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
List<Object[]>	ProjectableAdapter.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
List<Object[]>	ProjectableAdapter.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
List<Object[]>	ProjectableAdapter.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
ListSubQuery<Object[]>	DetachableQuery.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
ListSubQuery<Object[]>	DetachableQuery.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
ListSubQuery<Object[]>	DetachableQuery.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
ListSubQuery<Object[]>	DetachableMixin.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
ListSubQuery<Object[]>	DetachableMixin.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
ListSubQuery<Object[]>	DetachableMixin.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
ListSubQuery<Object[]>	DetachableAdapter.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
ListSubQuery<Object[]>	DetachableAdapter.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
ListSubQuery<Object[]>	DetachableAdapter.list(Expr<?> first, Expr<?> second, Expr<?>... rest)
<RT> List<RT>	ProjectableQuery.list(Expr<RT> projection)
<RT> List<RT>	ProjectableAdapter.list(Expr<RT> projection)
<RT> ListSubQuery<RT>	DetachableQuery.list(Expr<RT> projection)
<RT> ListSubQuery<RT>	DetachableMixin.list(Expr<RT> projection)
<RT> ListSubQuery<RT>	DetachableAdapter.list(Expr<RT> projection)
List<Object[]>	ProjectableQuery.listDistinct(Expr<?>[] args)
List<Object[]>	ProjectableAdapter.listDistinct(Expr<?>[] args)
List<Object[]>	ProjectableQuery.listDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
List<Object[]>	ProjectableQuery.listDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
List<Object[]>	ProjectableQuery.listDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
List<Object[]>	ProjectableAdapter.listDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
List<Object[]>	ProjectableAdapter.listDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
List<Object[]>	ProjectableAdapter.listDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
<RT> List<RT>	ProjectableQuery.listDistinct(Expr<RT> projection)
<RT> List<RT>	ProjectableAdapter.listDistinct(Expr<RT> projection)
<RT> SearchResults<RT>	ProjectableQuery.listDistinctResults(Expr<RT> projection)
<RT> SearchResults<RT>	ProjectableAdapter.listDistinctResults(Expr<RT> expr)
<RT> SearchResults<RT>	ProjectableAdapter.listResults(Expr<RT> expr)
<K,V> Map<K,V>	ProjectableQuery.map(Expr<K> key, Expr<V> value)
<K,V> Map<K,V>	ProjectableQuery.map(Expr<K> key, Expr<V> value)
<K,V> Map<K,V>	ProjectableAdapter.map(Expr<K> key, Expr<V> value)
<K,V> Map<K,V>	ProjectableAdapter.map(Expr<K> key, Expr<V> value)
ObjectSubQuery<Object[]>	DetachableQuery.unique(Expr<?>[] args)
ObjectSubQuery<Object[]>	DetachableMixin.unique(Expr<?>[] args)
ObjectSubQuery<Object[]>	DetachableAdapter.unique(Expr<?>[] args)
ObjectSubQuery<Object[]>	DetachableQuery.unique(Expr<?> first, Expr<?> second, Expr<?>... rest)
ObjectSubQuery<Object[]>	DetachableQuery.unique(Expr<?> first, Expr<?> second, Expr<?>... rest)
ObjectSubQuery<Object[]>	DetachableQuery.unique(Expr<?> first, Expr<?> second, Expr<?>... rest)
ObjectSubQuery<Object[]>	DetachableMixin.unique(Expr<?> first, Expr<?> second, Expr<?>... rest)
ObjectSubQuery<Object[]>	DetachableMixin.unique(Expr<?> first, Expr<?> second, Expr<?>... rest)
ObjectSubQuery<Object[]>	DetachableMixin.unique(Expr<?> first, Expr<?> second, Expr<?>... rest)
ObjectSubQuery<Object[]>	DetachableAdapter.unique(Expr<?> first, Expr<?> second, Expr<?>... rest)
ObjectSubQuery<Object[]>	DetachableAdapter.unique(Expr<?> first, Expr<?> second, Expr<?>... rest)
ObjectSubQuery<Object[]>	DetachableAdapter.unique(Expr<?> first, Expr<?> second, Expr<?>... rest)
<RT> ObjectSubQuery<RT>	DetachableQuery.unique(Expr<RT> projection)
<RT> ObjectSubQuery<RT>	DetachableMixin.unique(Expr<RT> projection)
<RT> ObjectSubQuery<RT>	DetachableAdapter.unique(Expr<RT> projection)
Object[]	ProjectableQuery.uniqueResult(Expr<?>[] args)
Object[]	ProjectableAdapter.uniqueResult(Expr<?>[] args)
Object[]	ProjectableQuery.uniqueResult(Expr<?> first, Expr<?> second, Expr<?>... rest)
Object[]	ProjectableQuery.uniqueResult(Expr<?> first, Expr<?> second, Expr<?>... rest)
Object[]	ProjectableQuery.uniqueResult(Expr<?> first, Expr<?> second, Expr<?>... rest)
Object[]	ProjectableAdapter.uniqueResult(Expr<?> first, Expr<?> second, Expr<?>... rest)
Object[]	ProjectableAdapter.uniqueResult(Expr<?> first, Expr<?> second, Expr<?>... rest)
Object[]	ProjectableAdapter.uniqueResult(Expr<?> first, Expr<?> second, Expr<?>... rest)
<RT> RT	ProjectableQuery.uniqueResult(Expr<RT> expr)
<RT> RT	ProjectableAdapter.uniqueResult(Expr<RT> expr)

Uses of Expr in com.mysema.query.types

Classes in com.mysema.query.types with type parameters of type Expr

static class	CaseBuilder.Cases<A,Q extends Expr<A>> Cascading typesafe Case builder
static class	CaseBuilder.CaseWhen<A,Q extends Expr<A>> Intermediate When state
class	CaseForEqBuilder.Cases<T,Q extends Expr<T>>
class	CaseForEqBuilder.CaseWhen<T,Q extends Expr<T>>

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

Expr<?>	Template.Element.convert(Expr<?> source)
Expr<A>	OrderSpecifier.getTarget() Get the target expression of this OrderSpecifier

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

<A> CaseBuilder.Cases<A,Expr<A>>	CaseBuilder.Initial.then(A constant)
<A> CaseBuilder.Cases<A,Expr<A>>	CaseBuilder.Initial.then(Expr<A> expr)
<T> CaseForEqBuilder.Cases<T,Expr<T>>	CaseForEqBuilder.then(Expr<T> then)
<T> CaseForEqBuilder.Cases<T,Expr<T>>	CaseForEqBuilder.then(T then)

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

Expr<?>	Template.Element.convert(Expr<?> source)
protected abstract Q	CaseBuilder.Cases.createResult(Class<A> type, Expr<A> last)
protected abstract Q	CaseForEqBuilder.Cases.createResult(Class<T> type, Expr<T> last)
SubType	VisitorBase.handle(Expr<?> expr)
Q	CaseBuilder.Cases.otherwise(Expr<A> expr)
Q	CaseForEqBuilder.Cases.otherwise(Expr<T> otherwise)
CaseBuilder.Cases<A,Q>	CaseBuilder.CaseWhen.then(Expr<A> expr)
<A> CaseBuilder.Cases<A,Expr<A>>	CaseBuilder.Initial.then(Expr<A> expr)
CaseForEqBuilder.Cases<T,Q>	CaseForEqBuilder.CaseWhen.then(Expr<T> then)
<T> CaseForEqBuilder.Cases<T,Expr<T>>	CaseForEqBuilder.then(Expr<T> then)
CaseForEqBuilder.CaseWhen<T,Q>	CaseForEqBuilder.Cases.when(Expr<? extends D> when)

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

CaseForEqBuilder.CaseWhen(CaseForEqBuilder.Cases<T,Q> cases, Expr<? extends D> when)

CaseForEqBuilder(Expr<D> base, Expr<? extends D> other)

CaseForEqBuilder(Expr<D> base, Expr<? extends D> other)

OrderSpecifier(Order order, Expr<A> target)

Uses of Expr in com.mysema.query.types.custom

Subclasses of Expr in com.mysema.query.types.custom

class	CBoolean CBoolean is a custom boolean expression
class	CComparable<T extends Comparable<?>> CComparable defines custom comparable expressions
class	CDate<T extends Comparable<?>>
class	CDateTime<T extends Comparable<?>>
class	CNumber<T extends Number & Comparable<?>> CNumber defines custom numeric expressions
class	CSimple<T> CSimple defines custom simple expressions
class	CString CString defines custom String expressions
class	CTime<T extends Comparable<?>>

Methods in com.mysema.query.types.custom that return Expr

static <T> Expr<T>	CSimple.create(Class<? extends T> type, String template, Expr<?>... args)
static <T> Expr<T>	CSimple.create(Class<? extends T> type, Template template, Expr<?>... args)
Expr<?>	Custom.getArg(int index) Get the argument with the given index
Expr<?>	CTime.getArg(int index)
Expr<?>	CString.getArg(int index)
Expr<?>	CSimple.getArg(int index)
Expr<?>	CNumber.getArg(int index)
Expr<?>	CDateTime.getArg(int index)
Expr<?>	CDate.getArg(int index)
Expr<?>	CComparable.getArg(int index)
Expr<?>	CBoolean.getArg(int index)

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

List<Expr<?>>	Custom.getArgs() Get the arguments of the custom expression
List<Expr<?>>	CTime.getArgs()
List<Expr<?>>	CString.getArgs()
List<Expr<?>>	CSimple.getArgs()
List<Expr<?>>	CNumber.getArgs()
List<Expr<?>>	CDateTime.getArgs()
List<Expr<?>>	CDate.getArgs()
List<Expr<?>>	CComparable.getArgs()
List<Expr<?>>	CBoolean.getArgs()

Methods in com.mysema.query.types.custom with parameters of type Expr

static <T> Expr<T>	CSimple.create(Class<? extends T> type, String template, Expr<?>... args)
static <T> Expr<T>	CSimple.create(Class<? extends T> type, Template template, Expr<?>... args)
static <T extends Comparable<?>> EComparable<T>	CTime.create(Class<T> type, String template, Expr<?>... args)
static <T extends Comparable<?>> EDateTime<T>	CDateTime.create(Class<T> type, String template, Expr<?>... args)
static <T extends Comparable<?>> EDate<T>	CDate.create(Class<T> type, String template, Expr<?>... args)
static <T extends Comparable<?>> EComparable<T>	CComparable.create(Class<T> type, String template, Expr<?>... args)
static <T extends Number & Comparable<?>> ENumber<T>	CNumber.create(Class<T> type, String template, Expr<?>... args)
static <T extends Comparable<?>> EComparable<T>	CTime.create(Class<T> type, Template template, Expr<?>... args)
static <T extends Comparable<?>> EDateTime<T>	CDateTime.create(Class<T> type, Template template, Expr<?>... args)
static <T extends Comparable<?>> EDate<T>	CDate.create(Class<T> type, Template template, Expr<?>... args)
static <T extends Comparable<?>> EComparable<T>	CComparable.create(Class<T> type, Template template, Expr<?>... args)
static <T extends Number & Comparable<?>> ENumber<T>	CNumber.create(Class<T> type, Template template, Expr<?>... args)
static EString	CString.create(String template, Expr<?>... args)
static EBoolean	CBoolean.create(String template, Expr<?>... args)
static EString	CString.create(Template template, Expr<?>... args)
static EBoolean	CBoolean.create(Template template, Expr<?>... args)

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

CBoolean(Template template, List<Expr<?>> args)

CComparable(Class<T> type, Template template, List<Expr<?>> args)

CDate(Class<T> type, Template template, List<Expr<?>> args)

CDateTime(Class<T> type, Template template, List<Expr<?>> args)

CNumber(Class<T> type, Template template, List<Expr<?>> args)

CSimple(Class<? extends T> type, Template template, List<Expr<?>> args)

CString(Template template, List<Expr<?>> args)

CTime(Class<T> type, Template template, List<Expr<?>> args)

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

Subclasses of Expr in com.mysema.query.types.expr

class	EArrayConstructor<D> EArrayConstructor extends EConstructor to represent array initializers
class	EBoolean EBoolean represents boolean expressions
class	EBooleanConst EBooleanConst provides constants for Boolean.TRUE and Boolean.FALSE
class	ECollectionBase<C extends Collection<E>,E> ECollectionBase is an abstract base class for ECollection implementations
class	EComparable<D extends Comparable> EComparable extends EComparableBase to provide comparison methods.
class	EComparableBase<D extends Comparable> EComparableBase represents comparable expressions
class	EConstructor<D> EConstructor represents a constructor invocation
class	EDate<D extends Comparable> EDate represents Date expressions
class	EDateConst
class	EDateOrTime<D extends Comparable> EDateOrTime is a supertype for Date/Time related types
class	EDateTime<D extends Comparable> EDateTime represents Date / Time expressions
class	EDateTimeConst
class	EMapBase<K,V> EMapBase is an abstract base class for EMap implementations
class	ENumber<D extends Number & Comparable<?>> ENumber represents a numeric expression
class	ENumberConst<D extends Number & Comparable<?>> ENumberConst represents numeric constants
class	EString EString represents String expressions
class	EStringConst EStringConst represents String constants
class	ETime<D extends Comparable> ETime represents Time expressions
class	ETimeConst
class	ExprConst<D> ExprConst represents general constant expressions

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

Expr<Character>	EString.charAt(Expr<Integer> i) Get the character at the given index
Expr<Character>	EStringConst.charAt(int i)
Expr<Character>	EString.charAt(int i) Get the character at the given index
static <T> Expr<T>	ExprConst.create(T val) Factory method for constants
Expr<E>	EList.get(Expr<Integer> index) Indexed access
Expr<E>	EArray.get(Expr<Integer> index)
Expr<V>	EMap.get(Expr<K> key) Get a this.get(key) expression
Expr<E>	EList.get(int index) Indexed access
Expr<E>	EArray.get(int index)
Expr<V>	EMap.get(K key) Get a this.get(key) expression
Expr<?>	EConstructor.getArg(int index) Get the constructor invocation argument with the given index
Expr<String[]>	EStringConst.split(String regex)
Expr<String[]>	EString.split(String regex) Split the given String with regex as the matcher for the separator

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

List<Expr<?>>

EConstructor.getArgs() Get the constructor invocation arguments

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

<N extends Number & Comparable<?>> ENumber<D>	ENumberConst.add(Expr<N> right)
<N extends Number & Comparable<?>> ENumber<D>	ENumber.add(Expr<N> right) Get the sum of this and right
EBoolean	EDateOrTime.after(Expr<D> right) Get a this > right expression
EString	EStringConst.append(Expr<String> s)
EString	EString.append(Expr<String> str) Get the concatenation of this and str
EBoolean	EDateOrTime.before(Expr<D> right) Get a this < right expression
<A extends Number & Comparable<?>> EBoolean	ENumber.between(Expr<A> from, Expr<A> to) Create a from < this < to expression
<A extends Number & Comparable<?>> EBoolean	ENumber.between(Expr<A> from, Expr<A> to) Create a from < this < to expression
EBoolean	EComparable.between(Expr<D> from, Expr<D> to) Get a first < this < second expression
EBoolean	EComparable.between(Expr<D> from, Expr<D> to) Get a first < this < second expression
Expr<Character>	EString.charAt(Expr<Integer> i) Get the character at the given index
EString	EString.concat(Expr<String> str) Get the concatenation of this and str
EBoolean	ECollectionBase.contains(Expr<E> child)
EBoolean	ECollection.contains(Expr<E> child) Get an expression for this.contains(child)
EBoolean	EMapBase.contains(Expr<K> key, Expr<V> value)
EBoolean	EMapBase.contains(Expr<K> key, Expr<V> value)
EBoolean	EMap.contains(Expr<K> key, Expr<V> value)
EBoolean	EMap.contains(Expr<K> key, Expr<V> value)
EBoolean	EString.contains(Expr<String> str) Returns true if the given String is contained
EBoolean	EString.contains(Expr<String> str, boolean caseSensitive) Returns true if the given String is contained
EBoolean	EMapBase.containsKey(Expr<K> key)
EBoolean	EMap.containsKey(Expr<K> key) Get a this.containsKey(key) expression
EBoolean	EMapBase.containsValue(Expr<V> value)
EBoolean	EMap.containsValue(Expr<V> value) Get a this.containsValue(value) expression
static <D> EConstructor<D>	EConstructor.create(Class<D> type, Expr<?>... args)
<N extends Number & Comparable<?>> ENumber<Double>	ENumber.divide(Expr<N> right) Get the result of the operation this / right
EBoolean	EString.endsWith(Expr<String> str) Returns true if this ends with str
EBoolean	EString.endsWith(Expr<String> str, boolean caseSensitive) Returns true if this ends with str
EBoolean	Expr.eq(Expr<? super D> right) Get a this == right expression
EBoolean	EString.equalsIgnoreCase(Expr<String> str) Compares this EString to another EString, ignoring case considerations.
Expr<E>	EList.get(Expr<Integer> index) Indexed access
Expr<E>	EArray.get(Expr<Integer> index)
Expr<V>	EMap.get(Expr<K> key) Get a this.get(key) expression
<A extends Number & Comparable<?>> EBoolean	ENumber.goe(Expr<A> right) Create a this >= right expression
EBoolean	EComparable.goe(Expr<D> right) Get a this >= right expression
<A extends Number & Comparable<?>> EBoolean	ENumber.gt(Expr<A> right) Create a this > right expression
EBoolean	EComparable.gt(Expr<D> right) Get a this > right expression
ENumber<Integer>	EString.indexOf(Expr<String> str) Get the index of the given substring in this String
ENumber<Integer>	EString.indexOf(Expr<String> str, int i) Get the index of the given substring in this String, starting from the given index
<A extends Number & Comparable<?>> EBoolean	ENumber.loe(Expr<A> right) Create a this <= right expression
EBoolean	EComparable.loe(Expr<D> right) Get a this < right expression
<A extends Number & Comparable<?>> EBoolean	ENumber.lt(Expr<A> right) Create a this < right expression
EBoolean	EComparable.lt(Expr<D> right) Get a this < right expression
EBoolean	EString.matches(Expr<String> regex) Return true if this String matches the given regular expression
static <A extends Number & Comparable<?>> ENumber<A>	ENumber.max(Expr<A> left, Expr<A> right) Return the greater of the given values
static <A extends Number & Comparable<?>> ENumber<A>	ENumber.max(Expr<A> left, Expr<A> right) Return the greater of the given values
static <A extends Number & Comparable<?>> ENumber<A>	ENumber.min(Expr<A> left, Expr<A> right) Return the smaller of the given values
static <A extends Number & Comparable<?>> ENumber<A>	ENumber.min(Expr<A> left, Expr<A> right) Return the smaller of the given values
<N extends Number & Comparable<?>> ENumber<D>	ENumber.multiply(Expr<N> right) Get the result of the operation this * right
EBoolean	Expr.ne(Expr<? super D> right) Get a this <> right expression
<A extends Number & Comparable<?>> EBoolean	ENumber.notBetween(Expr<A> from, Expr<A> to)
<A extends Number & Comparable<?>> EBoolean	ENumber.notBetween(Expr<A> from, Expr<A> to)
EBoolean	EComparable.notBetween(Expr<D> from, Expr<D> to)
EBoolean	EComparable.notBetween(Expr<D> from, Expr<D> to)
EString	EStringConst.prepend(Expr<String> s)
EString	EString.prepend(Expr<String> str) Prepend the given String and return the result
EBoolean	EString.startsWith(Expr<String> str) Return true if this starts with str
EBoolean	EString.startsWith(Expr<String> str, boolean caseSensitive) Return true if this starts with str
<N extends Number & Comparable<?>> ENumber<D>	ENumberConst.subtract(Expr<N> right)
<N extends Number & Comparable<?>> ENumber<D>	ENumber.subtract(Expr<N> right) Get the difference of this and right
CaseForEqBuilder<D>	Expr.when(Expr<? extends D> other)

Constructors in com.mysema.query.types.expr with parameters of type Expr

EArrayConstructor(Class<D> type, Expr<D>... args)

EConstructor(Class<D> type, Class<?>[] paramTypes, Expr<?>... args)

Uses of Expr in com.mysema.query.types.operation

Subclasses of Expr in com.mysema.query.types.operation

class	OBoolean OBoolean represents boolean operations
class	OComparable<OpType,D extends Comparable<?>> OComparable represents Comparable operations
class	ODate<OpType extends Comparable<?>,D extends Comparable<?>> ODate represents Date operations
class	ODateTime<OpType extends Comparable<?>,D extends Comparable<?>> ODateTime represents DateTime operations
class	ONumber<OpType extends Number,D extends Number & Comparable<?>> ONumber represents numeric operations
class	OSimple<OpType,D> OSimple represents a simple operation expression
class	OString OString represents a String typed operation
class	OTime<OpType,D extends Comparable<?>> OTime represents Time functions

Methods in com.mysema.query.types.operation that return Expr

Expr<D>	OSimple.asExpr()
Expr<RT>	OperationMixin.asExpr()
Expr<RT>	Operation.asExpr()
static <OpType,D> Expr<D>	OSimple.create(Class<? extends D> type, Operator<OpType> op, Expr<?>... args) Factory method
Expr<?>	OTime.getArg(int index)
Expr<?>	OString.getArg(int index)
Expr<?>	OSimple.getArg(int index)
Expr<?>	OperationMixin.getArg(int i)
Expr<?>	Operation.getArg(int index) Get the argument with the given index
Expr<?>	ONumber.getArg(int index)
Expr<?>	ODateTime.getArg(int index)
Expr<?>	ODate.getArg(int index)
Expr<?>	OComparable.getArg(int index)
Expr<?>	OBoolean.getArg(int index)

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

List<Expr<?>>	OTime.getArgs()
List<Expr<?>>	OString.getArgs()
List<Expr<?>>	OSimple.getArgs()
List<Expr<?>>	OperationMixin.getArgs()
List<Expr<?>>	Operation.getArgs() Get the arguments of this operation
List<Expr<?>>	ONumber.getArgs()
List<Expr<?>>	ODateTime.getArgs()
List<Expr<?>>	ODate.getArgs()
List<Expr<?>>	OComparable.getArgs()
List<Expr<?>>	OBoolean.getArgs()

Methods in com.mysema.query.types.operation with parameters of type Expr

static <O extends Number,D extends Number & Comparable<?>> ENumber<D>	ONumber.create(Class<? extends D> type, Operator<O> op, Expr<?>... args) Factory method
static <OpType,D> Expr<D>	OSimple.create(Class<? extends D> type, Operator<OpType> op, Expr<?>... args) Factory method
static <O,D extends Comparable<?>> ETime<D>	OTime.create(Class<D> type, Operator<O> op, Expr<?>... args) Factory method
static <O,D extends Comparable<?>> EComparable<D>	OComparable.create(Class<D> type, Operator<O> op, Expr<?>... args) Factory method
static <O extends Comparable<?>,D extends Comparable<?>> EDateTime<D>	ODateTime.create(Class<D> type, Operator<O> op, Expr<?>... args) Factory method
static <O extends Comparable<?>,D extends Comparable<?>> EDate<D>	ODate.create(Class<D> type, Operator<O> op, Expr<?>... args) Factory method
static EBoolean	OBoolean.create(Operator<Boolean> op, Expr<?>... args)
static EString	OString.create(Operator<String> op, Expr<?>... args)

Constructors in com.mysema.query.types.operation with parameters of type Expr

OperationMixin(Expr<RT> self, Operator<OP> operator, List<Expr<?>> args)

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

OperationMixin(Expr<RT> self, Operator<OP> operator, List<Expr<?>> args)

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

Classes in com.mysema.query.types.path with type parameters of type Expr

class	PList<E,Q extends Expr<E>> PList represents list paths
class	PMap<K,V,E extends Expr<V>> PMap represents map paths

Subclasses of Expr in com.mysema.query.types.path

class	PArray<E> PArray represents an array typed path
class	PathBuilder<D> PathBuilder is an extension to PEntity for dynamic path construction
class	PBoolean PBoolean represents boolean path expressions
class	PCollection<E> PCollection represents collection paths
class	PComparable<D extends Comparable> PComparable represents Comparable paths
class	PDate<D extends Comparable>
class	PDateTime<D extends Comparable>
class	PEntity<D> PEntity represents entity paths
class	PList<E,Q extends Expr<E>> PList represents list paths
class	PMap<K,V,E extends Expr<V>> PMap represents map paths
class	PNumber<D extends Number & Comparable<?>> PNumber represents numeric paths
class	PSet<E> PSet represents set paths
class	PSimple<D> PSimple represents simple paths
class	PString PString represents String typed paths
class	PTime<D extends Comparable>

Methods in com.mysema.query.types.path with type parameters of type Expr

protected <A,E extends Expr<A>> PList<A,E>	PEntity.createList(String property, Class<? super A> type, Class<? super E> queryType)
protected <K,V,E extends Expr<V>> PMap<K,V,E>	PEntity.createMap(String property, Class<? super K> key, Class<? super V> value, Class<? super E> queryType)
<A,E extends Expr<A>> PList<A,E>	PathBuilder.getList(String property, Class<A> type, Class<E> queryType)
<K,V,E extends Expr<V>> PMap<K,V,E>	PathBuilder.getMap(String property, Class<K> key, Class<V> value, Class<E> queryType)

Methods in com.mysema.query.types.path that return Expr

Expr<D>	PSimple.asExpr()
Expr<Set<E>>	PSet.asExpr()
Expr<List<E>>	PList.asExpr()
Expr<D>	PEntity.asExpr()
Expr<Collection<E>>	PCollection.asExpr()
Expr<C>	Path.asExpr()
Expr<E[]>	PArray.asExpr()
Expr<T>	PathMetadata.getExpression()

Methods in com.mysema.query.types.path with parameters of type Expr

static PathMetadata<Integer>	PathMetadataFactory.forArrayAccess(PArray<?> parent, Expr<Integer> index)
protected PathMetadata<Integer>	PList.forListAccess(Expr<Integer> index)
static PathMetadata<Integer>	PathMetadataFactory.forListAccess(PList<?,?> parent, Expr<Integer> index)
protected PathMetadata<K>	PMap.forMapAccess(Expr<K> key)
static <KT> PathMetadata<KT>	PathMetadataFactory.forMapAccess(PMap<?,?,?> parent, Expr<KT> key)
Q	PList.get(Expr<Integer> index)
PSimple<E>	PArray.get(Expr<Integer> index) Create a expression for indexed access
E	PMap.get(Expr<K> key)

Uses of Expr in com.mysema.query.types.query

Subclasses of Expr in com.mysema.query.types.query

class	ListSubQuery<A> List result subquery
class	ObjectSubQuery<A> Single result subquery