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

Packages that use Expr

com.mysema.query	Contains basic Query elements
com.mysema.query.alias	Alias functionality
com.mysema.query.collections	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.hibernate.sql
com.mysema.query.hql.jpa	HQL Support classes
com.mysema.query.hql.jpa.sql
com.mysema.query.jdoql	JDOQL support for Querydsl
com.mysema.query.lucene
com.mysema.query.serialization	Contains stubs for Serialization of queries
com.mysema.query.sql	SQL/JDBC support for Querydsl
com.mysema.query.sql.mssql
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	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 EBoolean expressions.

Methods in com.mysema.query that return Expr

Expr<?>	BooleanBuilder.getArg(int index)
Expr<?>	JoinExpression.getTarget()

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

List<Expr<?>>	BooleanBuilder.getArgs()
List<? extends Expr<?>>	QueryMetadata.getGroupBy() Get the group by expressions
List<? extends Expr<?>>	DefaultQueryMetadata.getGroupBy()
List<? extends Expr<?>>	QueryMetadata.getProjection() Get the projection
List<? extends Expr<?>>	DefaultQueryMetadata.getProjection()

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

void	QueryMetadata.addGroupBy(Expr<?>... o) Add the given group by expressions
void	DefaultQueryMetadata.addGroupBy(Expr<?>... o)
void	QueryMetadata.addJoin(JoinType joinType, Expr<?> expr) Add the given query join
void	DefaultQueryMetadata.addJoin(JoinType joinType, Expr<?> expr)
void	QueryMetadata.addProjection(Expr<?>... o) Add the given projections
void	DefaultQueryMetadata.addProjection(Expr<?>... o)
<T> T	Tuple.get(Expr<T> expr) Get a tuple element by expression
Q	Query.groupBy(Expr<?>... o) Defines the grouping/aggregation expressions
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterate(Expr<?>[] args) iterate over the results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the results for the given projection
<RT> com.mysema.commons.lang.CloseableIterator<RT>	Projectable.iterate(Expr<RT> projection) iterate over the results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterateDistinct(Expr<?>[] args) iterate over the distinct results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the distinct results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the distinct results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest) iterate over the distinct results for the given projection
<RT> com.mysema.commons.lang.CloseableIterator<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
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
<RT> List<RT>	Projectable.list(Expr<RT> projection) list the results 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
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
<A extends Expr<?>> A	AliasFactory.getCurrent()
<A extends Expr<?>> A	AliasFactory.getCurrentAndReset()

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)
<A> A	AliasFactory.createAliasForExpr(Class<A> cl, Expr<? extends A> expr)
<A> A	AliasFactory.createAliasForProperty(Class<A> cl, Object parent, Expr<?> path)
void	AliasFactory.setCurrent(Expr<?> path)

Uses of Expr in com.mysema.query.collections

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

<T> com.mysema.codegen.Evaluator<T>	DefaultEvaluatorFactory.create(QueryMetadata metadata, List<? extends Expr<?>> sources, Expr<T> projection) Create an Evaluator for the given query sources and projection
<T> com.mysema.codegen.Evaluator<List<T>>	DefaultEvaluatorFactory.createEvaluator(QueryMetadata metadata, Expr<? extends T> source, EBoolean filter) Create an Evaluator for the given source and filter
com.mysema.commons.lang.CloseableIterator<Object[]>	AbstractColQuery.iterate(Expr<?>[] args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	AbstractColQuery.iterate(Expr<RT> projection)
List<Object[]>	AbstractColQuery.list(Expr<?>[] args)
<RT> List<RT>	AbstractColQuery.list(Expr<RT> projection)
<T> List<T>	QueryEngine.list(QueryMetadata metadata, Map<Expr<?>,Iterable<?>> iterables, Expr<T> projection) Evaluate the given query and return the projection as a list
<T> List<T>	DefaultQueryEngine.list(QueryMetadata metadata, Map<Expr<?>,Iterable<?>> iterables, Expr<T> projection)
<RT> SearchResults<RT>	AbstractColQuery.listResults(Expr<RT> projection)

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

long	QueryEngine.count(QueryMetadata metadata, Map<Expr<?>,Iterable<?>> iterables) Evaluate the given query and return the count of matched rows
long	DefaultQueryEngine.count(QueryMetadata metadata, Map<Expr<?>,Iterable<?>> iterables)
<T> com.mysema.codegen.Evaluator<T>	DefaultEvaluatorFactory.create(QueryMetadata metadata, List<? extends Expr<?>> sources, Expr<T> projection) Create an Evaluator for the given query sources and projection
<T> List<T>	QueryEngine.list(QueryMetadata metadata, Map<Expr<?>,Iterable<?>> iterables, Expr<T> projection) Evaluate the given query and return the projection as a list
<T> List<T>	DefaultQueryEngine.list(QueryMetadata metadata, Map<Expr<?>,Iterable<?>> iterables, 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

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
com.mysema.commons.lang.CloseableIterator<Object[]>	AbstractHibernateQuery.iterate(Expr<?>[] args) Return the query results as an Iterator.
<RT> com.mysema.commons.lang.CloseableIterator<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.hibernate.sql

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

org.hibernate.Query	HibernateSQLQuery.createQuery(Expr<?>... args)
com.mysema.commons.lang.CloseableIterator<Object[]>	HibernateSQLQuery.iterate(Expr<?>[] args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	HibernateSQLQuery.iterate(Expr<RT> projection)
List<Object[]>	HibernateSQLQuery.list(Expr<?>[] projection)
<RT> List<RT>	HibernateSQLQuery.list(Expr<RT> projection)
<RT> SearchResults<RT>	HibernateSQLQuery.listResults(Expr<RT> projection)
<RT> RT	HibernateSQLQuery.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
com.mysema.commons.lang.CloseableIterator<Object[]>	AbstractJPAQuery.iterate(Expr<?>[] args)
<RT> com.mysema.commons.lang.CloseableIterator<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.hql.jpa.sql

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

javax.persistence.Query	JPASQLQuery.createQuery(Expr<?>... args)
com.mysema.commons.lang.CloseableIterator<Object[]>	JPASQLQuery.iterate(Expr<?>[] args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	JPASQLQuery.iterate(Expr<RT> projection)
List<Object[]>	JPASQLQuery.list(Expr<?>[] args)
<RT> List<RT>	JPASQLQuery.list(Expr<RT> projection)
<RT> SearchResults<RT>	JPASQLQuery.listResults(Expr<RT> projection)
<RT> RT	JPASQLQuery.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> T	JDOTuple.get(Expr<T> expr)
com.mysema.commons.lang.CloseableIterator<Object[]>	AbstractJDOQLQuery.iterate(Expr<?>[] args)
<RT> com.mysema.commons.lang.CloseableIterator<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.lucene

Subclasses of Expr in com.mysema.query.lucene

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.mysema.query.lucene with parameters of type Expr

org.apache.lucene.search.Query

LuceneSerializer.toQuery(QueryMetadata metadata, Expr<?> expr)

Uses of Expr in com.mysema.query.serialization

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

S	SerializerBase.handle(Expr<?> expr)

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

S	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

Q	AbstractSQLQuery.from(Expr<?>... args)
SQLQuery	SQLQuery.from(Expr<?>... o) Defines the sources of the query
ResultSet	AbstractSQLQuery.getResults(Expr<?>... exprs)
ResultSet	SQLQuery.getResults(Expr<?>... args) Get the results as an JDBC result set
com.mysema.commons.lang.CloseableIterator<Object[]>	AbstractSQLQuery.iterate(Expr<?>[] args)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	AbstractSQLQuery.iterate(Expr<RT> expr)
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

void	SQLSerializer.serializeForInsert(PEntity<?> entity, List<Path<?>> columns, List<Expr<?>> values, SubQuery<?> subQuery)
protected void	SQLSerializer.visitOperation(Class<?> type, Operator<?> operator, List<Expr<?>> args)

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

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

class

RowNumber RowNumber supports row_number constructs for MS SQL Server

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

RowNumber

RowNumber.partitionBy(Expr<?>... exprs)

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 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

T	QueryMixin.addToProjection(Expr<?>... o)
T	QueryMixin.from(Expr<?>... args)
T	QueryMixin.groupBy(Expr<?>... o)
Q	QueryBase.groupBy(Expr<?>... o)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterate(Expr<?>[] args)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterate(Expr<?> first, Expr<?> second, Expr<?>... rest)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	ProjectableAdapter.iterate(Expr<RT> projection)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterateDistinct(Expr<?>[] args)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterateDistinct(Expr<?>[] args)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterateDistinct(Expr<?> first, Expr<?> second, Expr<?>... rest)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	ProjectableAdapter.iterateDistinct(Expr<RT> projection)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	ProjectableQuery.iterateDistinct(Expr<RT> projection)
ListSubQuery<Object[]>	DetachableQuery.list(Expr<?>[] args)
List<Object[]>	ProjectableAdapter.list(Expr<?>[] args)
List<Object[]>	ProjectableQuery.list(Expr<?>[] args)
ListSubQuery<Object[]>	DetachableAdapter.list(Expr<?>[] args)
ListSubQuery<Object[]>	DetachableMixin.list(Expr<?>[] args)
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)
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)
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)
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)
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)
<RT> ListSubQuery<RT>	DetachableQuery.list(Expr<RT> projection)
<RT> List<RT>	ProjectableAdapter.list(Expr<RT> projection)
<RT> List<RT>	ProjectableQuery.list(Expr<RT> projection)
<RT> ListSubQuery<RT>	DetachableAdapter.list(Expr<RT> projection)
<RT> ListSubQuery<RT>	DetachableMixin.list(Expr<RT> projection)
List<Object[]>	ProjectableAdapter.listDistinct(Expr<?>[] args)
List<Object[]>	ProjectableQuery.listDistinct(Expr<?>[] args)
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)
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)
<RT> List<RT>	ProjectableAdapter.listDistinct(Expr<RT> projection)
<RT> List<RT>	ProjectableQuery.listDistinct(Expr<RT> projection)
<RT> SearchResults<RT>	ProjectableAdapter.listDistinctResults(Expr<RT> expr)
<RT> SearchResults<RT>	ProjectableQuery.listDistinctResults(Expr<RT> projection)
<RT> SearchResults<RT>	ProjectableAdapter.listResults(Expr<RT> expr)
<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)
<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)
ObjectSubQuery<Object[]>	DetachableQuery.unique(Expr<?>[] args)
ObjectSubQuery<Object[]>	DetachableAdapter.unique(Expr<?>[] args)
ObjectSubQuery<Object[]>	DetachableMixin.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[]>	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)
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)
<RT> ObjectSubQuery<RT>	DetachableQuery.unique(Expr<RT> projection)
<RT> ObjectSubQuery<RT>	DetachableAdapter.unique(Expr<RT> projection)
<RT> ObjectSubQuery<RT>	DetachableMixin.unique(Expr<RT> projection)
Object[]	ProjectableAdapter.uniqueResult(Expr<?>[] args)
Object[]	ProjectableQuery.uniqueResult(Expr<?>[] args)
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)
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)
<RT> RT	ProjectableAdapter.uniqueResult(Expr<RT> expr)
<RT> RT	ProjectableQuery.uniqueResult(Expr<RT> expr)

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

SimpleQueryAdapter(Q query, Expr<T> projection)

SimpleQueryAdapter(Query<?> query, Projectable projectable, Expr<T> projection)

Uses of Expr in com.mysema.query.types

Subclasses of Expr in com.mysema.query.types

class	EConstructor<D> EConstructor represents a constructor invocation
class	Param<T> Param defines a named parameter in a query

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

abstract Expr<D>	Expr.as(Path<D> alias)
Expr<D>	Constant.asExpr() Cast to Expr
Expr<T>	Custom.asExpr() Cast to Expr
Expr<C>	Path.asExpr() Cast to Expr
Expr<T>	SubQuery.asExpr() Cast to Expr
Expr<D>	Expr.asExpr() Used for safe casts from Path, SubQuery, Operation and Custom to Expr
Expr<RT>	Operation.asExpr() Cast to Expr
Expr<?>	Template.Element.convert(Expr<?> source)
Expr<?>	Custom.getArg(int index) Get the argument with the given index
Expr<?>	Operation.getArg(int index) Get the argument with the given index
Expr<T>	PathMetadata.getExpression()
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

List<Expr<?>>	Custom.getArgs() Get the arguments of the custom expression
List<Expr<?>>	EConstructor.getArgs() Get the constructor invocation arguments
List<Expr<?>>	Operation.getArgs() Get the arguments of this operation

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

Expr<?>	Template.Element.convert(Expr<?> source)
static <D> EConstructor<D>	EConstructor.create(Class<D> type, Expr<?>... args)
abstract EBoolean	Expr.eq(Expr<? super D> right) Get a this == right expression
abstract EBoolean	Expr.ne(Expr<? super D> right) Get a this <> right expression

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

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

OrderSpecifier(Order order, Expr<A> target)

PathMetadata(Path<?> parent, Expr<T> expression, PathType type)

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

Expr<T>	CustomMixin.asExpr()
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<?>	CString.getArg(int index)
Expr<?>	CDateTime.getArg(int index)
Expr<?>	CTime.getArg(int index)
Expr<?>	CSimple.getArg(int index)
Expr<?>	CComparable.getArg(int index)
Expr<?>	CustomMixin.getArg(int index)
Expr<?>	CDate.getArg(int index)
Expr<?>	CBoolean.getArg(int index)
Expr<?>	CNumber.getArg(int index)

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

List<Expr<?>>	CString.getArgs()
List<Expr<?>>	CDateTime.getArgs()
List<Expr<?>>	CTime.getArgs()
List<Expr<?>>	CSimple.getArgs()
List<Expr<?>>	CComparable.getArgs()
List<Expr<?>>	CustomMixin.getArgs()
List<Expr<?>>	CDate.getArgs()
List<Expr<?>>	CBoolean.getArgs()
List<Expr<?>>	CNumber.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<?>> EDateTime<T>	CDateTime.create(Class<T> type, String template, Expr<?>... args)
static <T extends Comparable<?>> EComparable<T>	CTime.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 Comparable<?>> EDate<T>	CDate.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<?>> EDateTime<T>	CDateTime.create(Class<T> type, Template template, Expr<?>... args)
static <T extends Comparable<?>> EComparable<T>	CTime.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 Comparable<?>> EDate<T>	CDate.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)

CustomMixin(Custom<T> self, List<Expr<?>> args, Template template)

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

Classes in com.mysema.query.types.expr 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>>

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

class	Coalesce<T extends Comparable> Coalesce defines a coalesce function invocation.
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	EDate<D extends Comparable> EDate represents Date expressions The date representation is compatible with the Gregorian calendar.
class	EDateConst<D extends Date>
class	EDateOrTime<D extends Comparable> EDateOrTime is a supertype for Date/Time related types
class	EDateTime<D extends Comparable> EDateTime represents Date / Time expressions The date representation is compatible with the Gregorian calendar.
class	EDateTimeConst<D extends Date>
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	ESimple<D> ESimple is the base class for Expr implementations.
class	EString EString represents String expressions
class	EStringConst EStringConst represents String constants
class	ETime<D extends Comparable> ETime represents Time expressions
class	ETimeConst<D extends Date>
class	ExprConst<D> ExprConst represents general constant expressions
class	OBoolean OBoolean represents boolean operations
class	OComparable<D extends Comparable<?>> OComparable represents Comparable operations
class	ODate<D extends Comparable<?>> ODate represents Date operations
class	ODateTime<D extends Comparable<?>> ODateTime represents DateTime operations
class	ONumber<D extends Number & Comparable<?>> ONumber represents numeric operations
class	OSimple<D> OSimple represents a simple operation expression
class	OString OString represents a String typed operation
class	OTime<D extends Comparable<?>> OTime represents Time functions
class	QTuple QTuple represents a projection of type Tuple

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

Expr<D>	ESimple.as(Path<D> alias) Create an alias for the operation
Expr<RT>	OperationMixin.asExpr()
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 <D> Expr<D>	OSimple.create(Class<D> type, Operator<? super D> op, Expr<?>... args) Factory method
static <T> Expr<T>	ExprConst.create(T val) Factory method for constants
Expr<E>	EArray.get(Expr<Integer> index) Get the element at the given index
Expr<E>	EList.get(Expr<Integer> index) Indexed access
Expr<V>	EMap.get(Expr<K> key) Get a this.get(key) expression
Expr<E>	EArray.get(int index) Get the element at the given index
Expr<E>	EList.get(int index) Indexed access
Expr<V>	EMap.get(K key) Get a this.get(key) expression
Expr<?>	OString.getArg(int index)
Expr<?>	OperationMixin.getArg(int i)
Expr<?>	ODate.getArg(int index)
Expr<?>	OComparable.getArg(int index)
Expr<?>	OSimple.getArg(int index)
Expr<?>	ONumber.getArg(int index)
Expr<?>	OTime.getArg(int index)
Expr<?>	OBoolean.getArg(int index)
Expr<?>	ODateTime.getArg(int 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<?>>	OString.getArgs()
List<Expr<?>>	OperationMixin.getArgs()
List<Expr<?>>	ODate.getArgs()
List<Expr<?>>	OComparable.getArgs()
List<Expr<?>>	OSimple.getArgs()
List<Expr<?>>	ONumber.getArgs()
List<Expr<?>>	OTime.getArgs()
List<Expr<?>>	OBoolean.getArgs()
List<Expr<?>>	ODateTime.getArgs()
<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.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
Coalesce<T>	Coalesce.add(Expr<T> expr)
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	ECollection.contains(Expr<E> child) Get an expression for this.contains(child)
EBoolean	ECollectionBase.contains(Expr<E> child)
EBoolean	EMap.contains(Expr<K> key, Expr<V> value)
EBoolean	EMap.contains(Expr<K> key, Expr<V> value)
EBoolean	EMapBase.contains(Expr<K> key, Expr<V> value)
EBoolean	EMapBase.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	EMap.containsKey(Expr<K> key) Get a this.containsKey(key) expression
EBoolean	EMapBase.containsKey(Expr<K> key)
EBoolean	EMap.containsValue(Expr<V> value) Get a this.containsValue(value) expression
EBoolean	EMapBase.containsValue(Expr<V> value)
static <D extends Number & Comparable<?>> ENumber<D>	ONumber.create(Class<? extends D> type, Operator<? super D> op, Expr<?>... args) Factory method
static <D> Expr<D>	OSimple.create(Class<D> type, Operator<? super D> op, Expr<?>... args) Factory method
static <D extends Comparable<?>> EDate<D>	ODate.create(Class<D> type, Operator<? super D> op, Expr<?>... args) Factory method
static <D extends Comparable<?>> EComparable<D>	OComparable.create(Class<D> type, Operator<? super D> op, Expr<?>... args) Factory method
static <D extends Comparable<?>> ETime<D>	OTime.create(Class<D> type, Operator<? super D> op, Expr<?>... args) Factory method
static <D extends Comparable<?>> EDateTime<D>	ODateTime.create(Class<D> type, Operator<? super D> op, Expr<?>... args) Factory method
static EBoolean	OBoolean.create(Operator<? super Boolean> op, Expr<?>... args)
static EString	OString.create(Operator<? super String> op, Expr<?>... args)
protected abstract Q	CaseBuilder.Cases.createResult(Class<A> type, Expr<A> last)
protected abstract Q	CaseForEqBuilder.Cases.createResult(Class<T> type, Expr<T> last)
<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	ESimple.eq(Expr<? super D> right)
EBoolean	EString.equalsIgnoreCase(Expr<String> str) Compares this EString to another EString, ignoring case considerations.
Expr<E>	EArray.get(Expr<Integer> index) Get the element at the given index
Expr<E>	EList.get(Expr<Integer> index) Indexed access
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	ESimple.ne(Expr<? super D> right)
<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) Get a this not between from and to expression
EBoolean	EComparable.notBetween(Expr<D> from, Expr<D> to) Get a this not between from and to expression
Q	CaseBuilder.Cases.otherwise(Expr<A> expr)
Q	CaseForEqBuilder.Cases.otherwise(Expr<T> otherwise)
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
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)
CaseForEqBuilder<D>	ESimple.when(Expr<? extends D> other) Get a case expression builder

Constructors in com.mysema.query.types.expr 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)

Coalesce(Class<? extends T> type, Expr... exprs)

Coalesce(Expr... exprs)

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

EArrayConstructor(Expr<?>... args)

QTuple(Expr<?>... args)

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

OperationMixin(Operation<RT> self, Operator<? super RT> 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) Create a new List typed path
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) Create a new Map typed path
<A,E extends Expr<A>> PList<A,E>	PathBuilder.getList(String property, Class<A> type, Class<E> queryType) Get a new List typed path
<K,V,E extends Expr<V>> PMap<K,V,E>	PathBuilder.getMap(String property, Class<K> key, Class<V> value, Class<E> queryType) Get a new Map typed path

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

Expr<T>

PathMixin.asExpr()

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

static PathMetadata<Integer>	PathMetadataFactory.forArrayAccess(PArray<?> parent, Expr<Integer> index)
static <T> PathMetadata<T>	PathMetadataFactory.forDelegate(Expr<T> target)
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)
PSimple<E>	PArray.get(Expr<Integer> index) Create a expression for indexed access
Q	PList.get(Expr<Integer> index)
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	BooleanSubQuery Single result subquery
class	ComparableSubQuery<A extends Comparable<?>> Single result subquery
class	DateSubQuery<A extends Comparable<?>> Single result subquery
class	DateTimeSubQuery<A extends Comparable<?>> Single result subquery
class	ListSubQuery<A> List result subquery
class	NumberSubQuery<A extends Number & Comparable<?>> Single result subquery
class	ObjectSubQuery<A> Single result subquery
class	StringSubQuery Single result subquery
class	TimeSubQuery<A extends Comparable<?>> Single result subquery

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

Expr<?>	ListSubQuery.as(Expr<?> alias)
Expr<T>	SubQueryMixin.asExpr()

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

Expr<?>	ListSubQuery.as(Expr<?> alias)
ListSubQuery<Object[]>	Detachable.list(Expr<?>[] args)
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> ListSubQuery<RT>	Detachable.list(Expr<RT> projection) Create a projection expression for the given projection
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 subquery expression for the given projection