|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Expression | |
---|---|
com.mysema.query | Contains basic Query elements |
com.mysema.query.alias | Alias functionality |
com.mysema.query.apt | APT related classes |
com.mysema.query.codegen | Code generations models and serializers |
com.mysema.query.collections | Implementations of Querydsl query interfaces for JavaBean collections |
com.mysema.query.dml | DML interfaces |
com.mysema.query.group | |
com.mysema.query.jdo | JDOQL support for Querydsl |
com.mysema.query.jdo.dml | DML operations support for Querydsl JDOQL |
com.mysema.query.jdo.sql | |
com.mysema.query.jpa | Query implementations for HQL and JPAQL |
com.mysema.query.jpa.hibernate | JPQL for Hibernate |
com.mysema.query.jpa.hibernate.sql | |
com.mysema.query.jpa.impl | JPQL for JPA |
com.mysema.query.jpa.sql | |
com.mysema.query.lucene | |
com.mysema.query.mongodb | |
com.mysema.query.sql | SQL/JDBC support for Querydsl |
com.mysema.query.sql.dml | DML operations support |
com.mysema.query.sql.mssql | SQL Server support |
com.mysema.query.sql.mysql | MySQL support |
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.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 |
com.mysema.query.types.template | Custom types are comparable to operations but contain the serialization templates instead of operator patterns. |
Uses of Expression in com.mysema.query |
---|
Classes in com.mysema.query that implement Expression | |
---|---|
class |
BooleanBuilder
BooleanBuilder is a cascading builder for Predicate expressions. |
Methods in com.mysema.query that return Expression | |
---|---|
Expression<?> |
BooleanBuilder.getArg(int index)
|
Expression<?> |
QueryFlag.getFlag()
|
Expression<?> |
JoinFlag.getFlag()
|
Expression<?> |
JoinExpression.getTarget()
|
Methods in com.mysema.query that return types with arguments of type Expression | |
---|---|
List<Expression<?>> |
BooleanBuilder.getArgs()
|
List<Expression<?>> |
QueryMetadata.getGroupBy()
Get the group by expressions |
List<Expression<?>> |
EmptyMetadata.getGroupBy()
|
List<Expression<?>> |
DefaultQueryMetadata.getGroupBy()
|
List<Expression<?>> |
QueryMetadata.getProjection()
Get the projection |
List<Expression<?>> |
EmptyMetadata.getProjection()
|
List<Expression<?>> |
DefaultQueryMetadata.getProjection()
|
Methods in com.mysema.query with parameters of type Expression | ||
---|---|---|
void |
QueryMetadata.addGroupBy(Expression<?>... o)
Add the given group by expressions |
|
void |
EmptyMetadata.addGroupBy(Expression<?>... o)
|
|
void |
DefaultQueryMetadata.addGroupBy(Expression<?>... o)
|
|
void |
QueryMetadata.addJoin(JoinType joinType,
Expression<?> expr)
Add the given query join |
|
void |
EmptyMetadata.addJoin(JoinType joinType,
Expression<?> expr)
|
|
void |
DefaultQueryMetadata.addJoin(JoinType joinType,
Expression<?> expr)
|
|
void |
QueryMetadata.addProjection(Expression<?>... o)
Add the given projections |
|
void |
EmptyMetadata.addProjection(Expression<?>... o)
|
|
void |
DefaultQueryMetadata.addProjection(Expression<?>... o)
|
|
|
Tuple.get(Expression<T> expr)
Get a tuple element by expression |
|
Q |
Query.groupBy(Expression<?>... o)
Defines the grouping/aggregation expressions |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
Projectable.iterate(Expression<?>[] args)
iterate over the results for the given projection |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
Projectable.iterate(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
iterate over the results for the given projection |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
Projectable.iterate(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
iterate over the results for the given projection |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
Projectable.iterate(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
iterate over the results for the given projection |
|
|
Projectable.iterate(Expression<RT> projection)
iterate over the results for the given projection |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
Projectable.iterateDistinct(Expression<?>[] args)
iterate over the distinct results for the given projection |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
Projectable.iterateDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
iterate over the distinct results for the given projection |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
Projectable.iterateDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
iterate over the distinct results for the given projection |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
Projectable.iterateDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
iterate over the distinct results for the given projection |
|
|
Projectable.iterateDistinct(Expression<RT> projection)
iterate over the distinct results for the given projection |
|
List<Object[]> |
Projectable.list(Expression<?>[] args)
list the results for the given projection An empty list is returned for no results. |
|
List<Object[]> |
Projectable.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
list the results for the given projection An empty list is returned for no results. |
|
List<Object[]> |
Projectable.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
list the results for the given projection An empty list is returned for no results. |
|
List<Object[]> |
Projectable.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
list the results for the given projection An empty list is returned for no results. |
|
|
Projectable.list(Expression<RT> projection)
list the results for the given projection An empty list is returned for no results. |
|
List<Object[]> |
Projectable.listDistinct(Expression<?>[] args)
list the distinct results for the given projection An empty list is returned for no results. |
|
List<Object[]> |
Projectable.listDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
list the distinct results for the given projection An empty list is returned for no results. |
|
List<Object[]> |
Projectable.listDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
list the distinct results for the given projection An empty list is returned for no results. |
|
List<Object[]> |
Projectable.listDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
list the distinct results for the given projection An empty list is returned for no results. |
|
|
Projectable.listDistinct(Expression<RT> projection)
list the distinct results for the given projection An empty list is returned for no results. |
|
|
Projectable.listDistinctResults(Expression<RT> projection)
list the distinct results for the given projection |
|
|
Projectable.listResults(Expression<RT> projection)
list the results for the given projection |
|
|
Projectable.map(Expression<K> key,
Expression<V> value)
return the given projection as a Map instance using key and value for Map population An empty map is returned for no results. |
|
|
Projectable.map(Expression<K> key,
Expression<V> value)
return the given projection as a Map instance using key and value for Map population An empty map is returned for no results. |
|
Object[] |
Projectable.singleResult(Expression<?>[] args)
return a single result for the given projection or null if no result is found |
|
Object[] |
Projectable.singleResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
return a single result for the given projection or null if no result is found |
|
Object[] |
Projectable.singleResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
return a single result for the given projection or null if no result is found |
|
Object[] |
Projectable.singleResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
return a single result for the given projection or null if no result is found |
|
|
Projectable.singleResult(Expression<RT> projection)
return a single result for the given projection or null if no result is found |
|
Object[] |
Projectable.uniqueResult(Expression<?>[] args)
return a unique result for the given projection or null if no result is found |
|
Object[] |
Projectable.uniqueResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
return a unique result for the given projection or null if no result is found |
|
Object[] |
Projectable.uniqueResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
return a unique result for the given projection or null if no result is found |
|
Object[] |
Projectable.uniqueResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
return a unique result for the given projection or null if no result is found |
|
|
Projectable.uniqueResult(Expression<RT> projection)
return a unique result for the given projection or null if no result is found |
Constructors in com.mysema.query with parameters of type Expression | |
---|---|
JoinExpression(JoinType type,
Expression<?> target)
Create a new JoinExpression instance |
|
JoinFlag(Expression<?> flag)
|
|
JoinFlag(Expression<?> flag,
JoinFlag.Position position)
|
|
QueryFlag(QueryFlag.Position position,
Expression<?> flag)
|
Uses of Expression in com.mysema.query.alias |
---|
Methods in com.mysema.query.alias with type parameters of type Expression | ||
---|---|---|
static
|
Alias.$()
Convert the given alias to an expression |
|
|
AliasFactory.getCurrent()
Get the current thread bound expression without reseting it |
|
|
AliasFactory.getCurrentAndReset()
Get the current thread bound expression and reset it |
Methods in com.mysema.query.alias that return Expression | ||
---|---|---|
static
|
Alias.getAny(D arg)
Convert the given alias to an expression |
Methods in com.mysema.query.alias with parameters of type Expression | ||
---|---|---|
static
|
Alias.alias(Class<A> cl,
Expression<? extends A> expr)
Create a new alias proxy of the given type for the given expression |
|
|
AliasFactory.createAliasForExpr(Class<A> cl,
Expression<? extends A> expr)
Create an alias instance for the given class and Expression |
|
|
AliasFactory.createAliasForProperty(Class<A> cl,
Object parent,
Expression<?> path)
Create an alias instance for the given class, parent and path |
|
protected
|
AliasFactory.createProxy(Class<A> cl,
Expression<?> path)
Create a proxy instance for the given class and path |
|
void |
AliasFactory.setCurrent(Expression<?> expr)
Set the thread bound expression to the given value |
Constructors in com.mysema.query.alias with parameters of type Expression | |
---|---|
PropertyAccessInvocationHandler(Expression<?> host,
AliasFactory aliasFactory,
PathFactory pathFactory,
TypeSystem typeSystem)
|
Uses of Expression in com.mysema.query.apt |
---|
Method parameters in com.mysema.query.apt with type arguments of type Expression | ||
---|---|---|
|
DefaultConfiguration.addCustomType(Class<T> type,
Class<? extends Expression<T>> queryType)
|
Uses of Expression in com.mysema.query.codegen |
---|
Method parameters in com.mysema.query.codegen with type arguments of type Expression | |
---|---|
void |
TypeMappings.register(com.mysema.codegen.model.TypeCategory category,
Class<? extends Expression> expr,
Class<? extends Path> path,
Class<? extends TemplateExpression> template)
|
Uses of Expression in com.mysema.query.collections |
---|
Methods in com.mysema.query.collections with parameters of type Expression | ||
---|---|---|
|
DefaultEvaluatorFactory.create(QueryMetadata metadata,
List<? extends Expression<?>> sources,
Expression<T> projection)
Create an Evaluator for the given query sources and projection |
|
|
DefaultEvaluatorFactory.createEvaluator(QueryMetadata metadata,
Expression<? extends T> source,
Predicate filter)
Create an Evaluator for the given source and filter |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
AbstractColQuery.iterate(Expression<?>[] args)
|
|
|
AbstractColQuery.iterate(Expression<RT> projection)
|
|
List<Object[]> |
AbstractColQuery.list(Expression<?>[] args)
|
|
|
AbstractColQuery.list(Expression<RT> projection)
|
|
|
QueryEngine.list(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables,
Expression<T> projection)
Evaluate the given query and return the projection as a list |
|
|
DefaultQueryEngine.list(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables,
Expression<T> projection)
|
|
|
AbstractColQuery.listResults(Expression<RT> projection)
|
|
|
ColUpdateClause.set(Path<U> path,
Expression<? extends U> expression)
|
|
Object[] |
AbstractColQuery.uniqueResult(Expression<?>[] args)
|
|
|
AbstractColQuery.uniqueResult(Expression<RT> expr)
|
|
static
|
GuavaHelpers.wrap(Expression<T> projection)
Wrap a Querydsl expression into a Guava function |
Method parameters in com.mysema.query.collections with type arguments of type Expression | ||
---|---|---|
long |
QueryEngine.count(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables)
Evaluate the given query and return the count of matched rows |
|
long |
DefaultQueryEngine.count(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables)
|
|
|
DefaultEvaluatorFactory.create(QueryMetadata metadata,
List<? extends Expression<?>> sources,
Expression<T> projection)
Create an Evaluator for the given query sources and projection |
|
boolean |
QueryEngine.exists(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables)
|
|
boolean |
DefaultQueryEngine.exists(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables)
|
|
|
QueryEngine.list(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables,
Expression<T> projection)
Evaluate the given query and return the projection as a list |
|
|
DefaultQueryEngine.list(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables,
Expression<T> projection)
|
|
protected void |
ColQuerySerializer.visitOperation(Class<?> type,
Operator<?> operator,
List<? extends Expression<?>> args)
|
Uses of Expression in com.mysema.query.dml |
---|
Methods in com.mysema.query.dml with parameters of type Expression | ||
---|---|---|
|
StoreClause.set(Path<T> path,
Expression<? extends T> expression)
Add an expression binding |
Uses of Expression in com.mysema.query.group |
---|
Subinterfaces of Expression in com.mysema.query.group | |
---|---|
interface |
GroupExpression<T,R>
Defines the way results of a given expression are grouped. |
Classes in com.mysema.query.group that implement Expression | |
---|---|
class |
AbstractGroupExpression<T,R>
A base class for GroupExpressions |
class |
GAvg<T extends Number & Comparable<T>>
|
class |
GSum<T extends Number & Comparable<T>>
|
class |
QPair<K,V>
A pair of (Map) key and value |
Fields in com.mysema.query.group declared as Expression | |
---|---|
protected Expression<?>[] |
GroupBy.expressions
|
Methods in com.mysema.query.group that return Expression | ||
---|---|---|
Expression<T> |
GroupExpression.getExpression()
|
|
Expression<T> |
AbstractGroupExpression.getExpression()
|
|
static
|
GroupBy.map(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression |
Methods in com.mysema.query.group with parameters of type Expression | ||
---|---|---|
ResultTransformer<Map<K,Group>> |
GroupByBuilder.as(Expression<?>... expressions)
|
|
|
GroupByBuilder.as(Expression<V> expression)
|
|
static
|
GroupBy.avg(Expression<E> expression)
Create a new aggregating avg expression |
|
static
|
QPair.create(Expression<K> key,
Expression<V> value)
|
|
static
|
QPair.create(Expression<K> key,
Expression<V> value)
|
|
boolean |
QPair.equals(Expression<?> keyExpr,
Class<?> valueType)
|
|
boolean |
QPair.equals(Expression<?> keyExpr,
Expression<?> valueExpr)
|
|
boolean |
QPair.equals(Expression<?> keyExpr,
Expression<?> valueExpr)
|
|
|
Group.getList(Expression<T> expr)
Returns a List of values in this group. |
|
|
Group.getMap(Expression<K> key,
Expression<V> value)
Returns a Map of values in this group |
|
|
Group.getMap(Expression<K> key,
Expression<V> value)
Returns a Map of values in this group |
|
|
Group.getOne(Expression<T> expr)
Returns the value of the given single valued expression. |
|
|
Group.getSet(Expression<T> expr)
Returns a Set of values in this group. |
|
static
|
GroupBy.groupBy(Expression<K> key)
Create a new GroupByBuilder for the given key expression |
|
static
|
GroupBy.list(Expression<E> expression)
Create a new aggregating list expression |
|
static
|
GroupBy.map(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression |
|
static
|
GroupBy.map(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression |
|
static
|
GroupBy.max(Expression<E> expression)
Create a new aggregating max expression |
|
static
|
GroupBy.min(Expression<E> expression)
Create a new aggregating min expression |
|
static
|
GroupBy.set(Expression<E> expression)
Create a new aggregating set expression |
|
static
|
GroupBy.sum(Expression<E> expression)
Create a new aggregating sum expression |
Constructors in com.mysema.query.group with parameters of type Expression | |
---|---|
AbstractGroupExpression(Class<? super R> type,
Expression<T> expr)
|
|
GAvg(Expression<T> expr)
|
|
GroupByBuilder(Expression<K> key)
Create a new GroupByBuilder for the given key expression |
|
GroupByProjection(Expression<K> key,
Expression<?>... expressions)
|
|
GroupByProjection(Expression<K> key,
Expression<?>... expressions)
|
|
GSum(Expression<T> expr)
|
|
QPair(Expression<K> key,
Expression<V> value)
|
|
QPair(Expression<K> key,
Expression<V> value)
|
Uses of Expression in com.mysema.query.jdo |
---|
Methods in com.mysema.query.jdo that return Expression | |
---|---|
Expression<?> |
JDOQLSerializer.getCandidatePath()
|
Methods in com.mysema.query.jdo with parameters of type Expression | ||
---|---|---|
|
JDOTuple.get(Expression<T> expr)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
AbstractJDOQLQuery.iterate(Expression<?>[] args)
|
|
|
AbstractJDOQLQuery.iterate(Expression<RT> projection)
|
|
List<Object[]> |
AbstractJDOQLQuery.list(Expression<?>[] args)
|
|
|
AbstractJDOQLQuery.list(Expression<RT> expr)
|
|
|
AbstractJDOQLQuery.listResults(Expression<RT> expr)
|
|
Object[] |
AbstractJDOQLQuery.uniqueResult(Expression<?>[] args)
|
|
|
AbstractJDOQLQuery.uniqueResult(Expression<RT> expr)
|
Method parameters in com.mysema.query.jdo with type arguments of type Expression | |
---|---|
protected void |
JDOQLSerializer.visitOperation(Class<?> type,
Operator<?> operator,
List<? extends Expression<?>> args)
|
Constructors in com.mysema.query.jdo with parameters of type Expression | |
---|---|
JDOQLSerializer(JDOQLTemplates templates,
Expression<?> candidate)
|
Uses of Expression in com.mysema.query.jdo.dml |
---|
Methods in com.mysema.query.jdo.dml with parameters of type Expression | ||
---|---|---|
|
JDOQLUpdateClause.set(Path<T> path,
Expression<? extends T> expression)
|
Uses of Expression in com.mysema.query.jdo.sql |
---|
Methods in com.mysema.query.jdo.sql with parameters of type Expression | ||
---|---|---|
T |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
Expression<?> flag)
|
|
T |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
String prefix,
Expression<?> expr)
|
|
T |
AbstractSQLQuery.from(Expression<?>... args)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
JDOSQLQuery.iterate(Expression<?>[] args)
|
|
|
JDOSQLQuery.iterate(Expression<RT> projection)
|
|
List<Object[]> |
JDOSQLQuery.list(Expression<?>[] args)
|
|
|
JDOSQLQuery.list(Expression<RT> expr)
|
|
|
JDOSQLQuery.listResults(Expression<RT> expr)
|
|
Object[] |
JDOSQLQuery.uniqueResult(Expression<?>[] args)
|
|
|
JDOSQLQuery.uniqueResult(Expression<RT> expr)
|
Uses of Expression in com.mysema.query.jpa |
---|
Methods in com.mysema.query.jpa that return Expression | ||
---|---|---|
|
JPQLQueryMixin.convert(Expression<RT> expr)
|
|
static
|
Conversions.convert(Expression<RT> expr)
|
Methods in com.mysema.query.jpa with parameters of type Expression | ||
---|---|---|
T |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
Expression<?> flag)
|
|
T |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
String prefix,
Expression<?> expr)
|
|
|
JPQLQueryMixin.convert(Expression<RT> expr)
|
|
static
|
Conversions.convert(Expression<RT> expr)
|
|
T |
AbstractSQLQuery.from(Expression<?>... args)
|
Method parameters in com.mysema.query.jpa with type arguments of type Expression | |
---|---|
protected void |
JPQLSerializer.visitOperation(Class<?> type,
Operator<?> operator,
List<? extends Expression<?>> args)
|
Uses of Expression in com.mysema.query.jpa.hibernate |
---|
Methods in com.mysema.query.jpa.hibernate with parameters of type Expression | ||
---|---|---|
org.hibernate.Query |
AbstractHibernateQuery.createQuery(Expression<?> expr)
Expose the original Hibernate query for the given projection |
|
org.hibernate.Query |
AbstractHibernateQuery.createQuery(Expression<?>[] args)
Expose the original Hibernate query for the given projection |
|
org.hibernate.Query |
AbstractHibernateQuery.createQuery(Expression<?> expr1,
Expression<?> expr2,
Expression<?>... rest)
Expose the original Hibernate query for the given projection |
|
org.hibernate.Query |
AbstractHibernateQuery.createQuery(Expression<?> expr1,
Expression<?> expr2,
Expression<?>... rest)
Expose the original Hibernate query for the given projection |
|
org.hibernate.Query |
AbstractHibernateQuery.createQuery(Expression<?> expr1,
Expression<?> expr2,
Expression<?>... rest)
Expose the original Hibernate query for the given projection |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
AbstractHibernateQuery.iterate(Expression<?>[] args)
Return the query results as an Iterator. |
|
|
AbstractHibernateQuery.iterate(Expression<RT> projection)
Return the query results as an Iterator. |
|
List<Object[]> |
AbstractHibernateQuery.list(Expression<?>[] args)
|
|
|
AbstractHibernateQuery.list(Expression<RT> expr)
|
|
|
AbstractHibernateQuery.listResults(Expression<RT> expr)
|
|
org.hibernate.ScrollableResults |
AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode,
Expression<?> expr)
Return the query results as ScrollableResults. |
|
org.hibernate.ScrollableResults |
AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode,
Expression<?>[] args)
Return the query results as ScrollableResults. |
|
org.hibernate.ScrollableResults |
AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode,
Expression<?> expr1,
Expression<?> expr2,
Expression<?>... rest)
Return the query results as ScrollableResults. |
|
org.hibernate.ScrollableResults |
AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode,
Expression<?> expr1,
Expression<?> expr2,
Expression<?>... rest)
Return the query results as ScrollableResults. |
|
org.hibernate.ScrollableResults |
AbstractHibernateQuery.scroll(org.hibernate.ScrollMode mode,
Expression<?> expr1,
Expression<?> expr2,
Expression<?>... rest)
Return the query results as ScrollableResults. |
|
|
HibernateUpdateClause.set(Path<T> path,
Expression<? extends T> expression)
|
|
Object[] |
AbstractHibernateQuery.uniqueResult(Expression<?>[] args)
|
|
|
AbstractHibernateQuery.uniqueResult(Expression<RT> expr)
|
Uses of Expression in com.mysema.query.jpa.hibernate.sql |
---|
Methods in com.mysema.query.jpa.hibernate.sql with parameters of type Expression | ||
---|---|---|
org.hibernate.Query |
AbstractHibernateSQLQuery.createQuery(Expression<?>... args)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
AbstractHibernateSQLQuery.iterate(Expression<?>[] args)
|
|
|
AbstractHibernateSQLQuery.iterate(Expression<RT> projection)
|
|
List<Object[]> |
AbstractHibernateSQLQuery.list(Expression<?>[] projection)
|
|
|
AbstractHibernateSQLQuery.list(Expression<RT> projection)
|
|
|
AbstractHibernateSQLQuery.listResults(Expression<RT> projection)
|
|
Object[] |
AbstractHibernateSQLQuery.uniqueResult(Expression<?>[] args)
|
|
|
AbstractHibernateSQLQuery.uniqueResult(Expression<RT> expr)
|
Uses of Expression in com.mysema.query.jpa.impl |
---|
Methods in com.mysema.query.jpa.impl with parameters of type Expression | ||
---|---|---|
javax.persistence.Query |
AbstractJPAQuery.createQuery(Expression<?> expr)
Expose the original JPA query for the given projection |
|
javax.persistence.Query |
AbstractJPAQuery.createQuery(Expression<?>[] args)
Expose the original JPA query for the given projection |
|
javax.persistence.Query |
AbstractJPAQuery.createQuery(Expression<?> expr1,
Expression<?> expr2,
Expression<?>... rest)
Expose the original JPA query for the given projection |
|
javax.persistence.Query |
AbstractJPAQuery.createQuery(Expression<?> expr1,
Expression<?> expr2,
Expression<?>... rest)
Expose the original JPA query for the given projection |
|
javax.persistence.Query |
AbstractJPAQuery.createQuery(Expression<?> expr1,
Expression<?> expr2,
Expression<?>... rest)
Expose the original JPA query for the given projection |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
AbstractJPAQuery.iterate(Expression<?>[] args)
|
|
|
AbstractJPAQuery.iterate(Expression<RT> projection)
|
|
List<Object[]> |
AbstractJPAQuery.list(Expression<?>[] args)
|
|
|
AbstractJPAQuery.list(Expression<RT> expr)
|
|
|
AbstractJPAQuery.listResults(Expression<RT> expr)
|
|
|
JPAUpdateClause.set(Path<T> path,
Expression<? extends T> expression)
|
|
Object[] |
AbstractJPAQuery.uniqueResult(Expression<?>[] args)
|
|
|
AbstractJPAQuery.uniqueResult(Expression<RT> expr)
|
Uses of Expression in com.mysema.query.jpa.sql |
---|
Methods in com.mysema.query.jpa.sql with parameters of type Expression | ||
---|---|---|
javax.persistence.Query |
AbstractJPASQLQuery.createQuery(Expression<?>... args)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
AbstractJPASQLQuery.iterate(Expression<?>[] args)
|
|
|
AbstractJPASQLQuery.iterate(Expression<RT> projection)
|
|
List<Object[]> |
AbstractJPASQLQuery.list(Expression<?>[] args)
|
|
|
AbstractJPASQLQuery.list(Expression<RT> projection)
|
|
|
AbstractJPASQLQuery.listResults(Expression<RT> projection)
|
|
Object[] |
AbstractJPASQLQuery.uniqueResult(Expression<?>[] args)
|
|
|
AbstractJPASQLQuery.uniqueResult(Expression<RT> expr)
|
Uses of Expression in com.mysema.query.lucene |
---|
Classes in com.mysema.query.lucene that implement Expression | |
---|---|
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 Expression | |
---|---|
protected String[] |
LuceneSerializer.convert(Path<?> leftHandSide,
Expression<?> rightHandSide,
QueryMetadata metadata)
template method |
protected org.apache.lucene.search.Query |
LuceneSerializer.range(Path<?> leftHandSide,
String field,
Expression<?> min,
Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata)
|
protected org.apache.lucene.search.Query |
LuceneSerializer.range(Path<?> leftHandSide,
String field,
Expression<?> min,
Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata)
|
protected org.apache.lucene.search.Query |
LuceneSerializer.stringRange(Path<?> leftHandSide,
String field,
Expression<?> min,
Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata)
|
protected org.apache.lucene.search.Query |
LuceneSerializer.stringRange(Path<?> leftHandSide,
String field,
Expression<?> min,
Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata)
|
org.apache.lucene.search.Query |
LuceneSerializer.toQuery(Expression<?> expr,
QueryMetadata metadata)
|
Uses of Expression in com.mysema.query.mongodb |
---|
Classes in com.mysema.query.mongodb that implement Expression | |
---|---|
class |
Point
Point is an adapter type for Double[] arrays to use geo spatial querying features of Mongodb |
Methods in com.mysema.query.mongodb with parameters of type Expression | |
---|---|
Object |
MongodbSerializer.handle(Expression<?> expression)
|
Uses of Expression in com.mysema.query.sql |
---|
Subinterfaces of Expression in com.mysema.query.sql | |
---|---|
interface |
RelationalPath<T>
RelationalPath extends EntityPath to provide access to relational metadata |
Classes in com.mysema.query.sql that implement Expression | |
---|---|
class |
QBeans
Expression used to project a list of beans |
class |
RelationalFunctionCall<T>
Represents a table valued function call |
class |
RelationalPathBase<T>
RelationalPathBase is a base class for RelationalPath implementations |
Fields in com.mysema.query.sql declared as Expression | |
---|---|
static Expression<Object[]> |
SQLExpressions.all
|
static Expression<Long> |
SQLExpressions.countAll
|
Methods in com.mysema.query.sql that return Expression | |
---|---|
static Expression<?> |
UnionUtils.combineUnion(SubQueryExpression<?>[] union,
Path<?> alias,
SQLTemplates templates,
boolean unionAll)
|
Expression<?> |
RelationalFunctionCall.getArg(int index)
|
Methods in com.mysema.query.sql that return types with arguments of type Expression | |
---|---|
List<Expression<?>> |
QBeans.getArgs()
|
List<Expression<?>> |
RelationalFunctionCall.getArgs()
|
Methods in com.mysema.query.sql with parameters of type Expression | ||
---|---|---|
Q |
AbstractSQLSubQuery.addFlag(QueryFlag.Position position,
Expression<?> flag)
Add the given Expression as a query flag |
|
Q |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
Expression<?> flag)
Add the given Expression as a query flag |
|
Q |
SQLCommonQuery.addFlag(QueryFlag.Position position,
Expression<?> flag)
Add the given Expression as a query flag |
|
Q |
AbstractSQLSubQuery.addFlag(QueryFlag.Position position,
String prefix,
Expression<?> expr)
Add the given prefix and expression as a general query flag |
|
Q |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
String prefix,
Expression<?> expr)
Add the given prefix and expression as a general query flag |
|
Q |
SQLCommonQuery.addFlag(QueryFlag.Position position,
String prefix,
Expression<?> expr)
Add the given prefix and expression as a general query flag |
|
Q |
AbstractSQLSubQuery.from(Expression<?>... args)
|
|
Q |
AbstractSQLQuery.from(Expression<?>... args)
|
|
Q |
SQLCommonQuery.from(Expression<?>... o)
Defines the sources of the query |
|
Q |
AbstractSQLQueryFactory.from(Expression<?> from)
|
|
Q |
SQLQueryFactory.from(Expression<?> from)
Create a new SELECT query |
|
ResultSet |
AbstractSQLQuery.getResults(Expression<?>... exprs)
|
|
ResultSet |
SQLQuery.getResults(Expression<?>... args)
Get the results as an JDBC result set |
|
Union<RT> |
UnionImpl.groupBy(Expression<?>... o)
|
|
Union<RT> |
Union.groupBy(Expression<?>... o)
Defines the grouping/aggregation expressions |
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
AbstractSQLQuery.iterate(Expression<?>[] args)
|
|
|
AbstractSQLQuery.iterate(Expression<RT> expr)
|
|
List<Object[]> |
AbstractSQLQuery.list(Expression<?>[] args)
|
|
|
AbstractSQLQuery.list(Expression<RT> expr)
|
|
|
AbstractSQLQuery.listResults(Expression<RT> expr)
|
|
SQLSubQuery |
AbstractSQLQueryFactory.subQuery(Expression<?> from)
|
|
SQ |
SQLQueryFactory.subQuery(Expression<?> from)
|
|
Object[] |
AbstractSQLQuery.uniqueResult(Expression<?>[] expr)
|
|
|
AbstractSQLQuery.uniqueResult(Expression<RT> expr)
|
Method parameters in com.mysema.query.sql with type arguments of type Expression | |
---|---|
void |
SQLSerializer.serializeForInsert(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery)
|
void |
SQLSerializer.serializeForMerge(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery)
|
void |
SQLSerializer.serializeForUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates)
|
protected void |
SQLSerializer.visitOperation(Class<?> type,
Operator<?> operator,
List<? extends Expression<?>> args)
|
Constructor parameters in com.mysema.query.sql with type arguments of type Expression | |
---|---|
UnionImpl(Q query,
List<? extends Expression<?>> projection)
|
Uses of Expression in com.mysema.query.sql.dml |
---|
Methods in com.mysema.query.sql.dml that return types with arguments of type Expression | |
---|---|
List<Expression<?>> |
SQLMergeBatch.getValues()
|
List<Expression<?>> |
SQLInsertBatch.getValues()
|
Methods in com.mysema.query.sql.dml with parameters of type Expression | ||
---|---|---|
SQLMergeClause |
SQLMergeClause.addFlag(QueryFlag.Position position,
Expression<?> flag)
Add the given Expression at the given position as a query flag |
|
SQLInsertClause |
SQLInsertClause.addFlag(QueryFlag.Position position,
Expression<?> flag)
Add the given Expression at the given position as a query flag |
|
SQLUpdateClause |
SQLUpdateClause.addFlag(QueryFlag.Position position,
Expression<?> flag)
Add the given Expression at the given position as a query flag |
|
SQLDeleteClause |
SQLDeleteClause.addFlag(QueryFlag.Position position,
Expression<?> flag)
Add the given Expression at the given position as a query flag |
|
|
SQLMergeClause.set(Path<T> path,
Expression<? extends T> expression)
|
|
|
SQLInsertClause.set(Path<T> path,
Expression<? extends T> expression)
|
|
|
SQLUpdateClause.set(Path<T> path,
Expression<? extends T> expression)
|
Constructor parameters in com.mysema.query.sql.dml with type arguments of type Expression | |
---|---|
SQLInsertBatch(List<Path<?>> c,
List<Expression<?>> v,
SubQueryExpression<?> sq)
|
|
SQLMergeBatch(List<Path<?>> k,
List<Path<?>> c,
List<Expression<?>> v,
SubQueryExpression<?> sq)
|
Uses of Expression in com.mysema.query.sql.mssql |
---|
Classes in com.mysema.query.sql.mssql that implement Expression | |
---|---|
class |
RowNumber
RowNumber supports row_number constructs for MS SQL Server |
Methods in com.mysema.query.sql.mssql with parameters of type Expression | |
---|---|
RowNumber |
RowNumber.as(Expression<Long> target)
|
RowNumber |
RowNumber.partitionBy(Expression<?>... exprs)
|
Uses of Expression in com.mysema.query.sql.mysql |
---|
Methods in com.mysema.query.sql.mysql with parameters of type Expression | |
---|---|
SQLInsertClause |
MySQLQueryFactory.insertOnDuplicateKeyUpdate(RelationalPath<?> entity,
Expression<?> clause)
|
Uses of Expression in com.mysema.query.sql.oracle |
---|
Classes in com.mysema.query.sql.oracle that implement Expression | |
---|---|
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 Expression | ||
---|---|---|
SumOver<A> |
SumOver.orderBy(Expression<?>... orderBy)
|
|
OracleQuery |
OracleQuery.orderSiblingsBy(Expression<?> path)
|
|
SumOver<A> |
SumOver.partition(Expression<?> partitionBy)
|
|
static
|
OracleGrammar.sumOver(Expression<A> expr)
|
Constructors in com.mysema.query.sql.oracle with parameters of type Expression | |
---|---|
SumOver(Expression<A> expr)
|
Uses of Expression in com.mysema.query.support |
---|
Classes in com.mysema.query.support that implement Expression | |
---|---|
class |
NumberConversion<T>
NumberConversion ensures that the results of a numeric projection confirm to the type of the projection expression |
class |
NumberConversions<T>
NumberConversions ensures that the results of a projection involving numeric expressions confirm to the types of the numeric expressions |
Methods in com.mysema.query.support that return Expression | ||
---|---|---|
static
|
Expressions.constant(T value)
|
|
Expression<?>[] |
QueryMixin.convert(Expression<?>[] exprs)
|
|
|
QueryMixin.convert(Expression<RT> expr)
|
|
protected
|
QueryMixin.createAlias(Expression<D> path,
Path<D> alias)
|
|
protected
|
QueryMixin.createAlias(MapExpression<?,D> target,
Path<D> alias)
|
|
protected
|
QueryMixin.createAlias(Path<? extends Collection<D>> target,
Path<D> alias)
|
|
protected
|
QueryMixin.createAlias(SubQueryExpression<D> path,
Path<D> alias)
|
|
Expression<?> |
CollectionAnyVisitor.visit(Constant<?> expr,
Context context)
|
|
Expression<?> |
ListAccessVisitor.visit(Constant<?> expr,
Context context)
|
|
Expression<?> |
CollectionAnyVisitor.visit(FactoryExpression<?> expr,
Context context)
|
|
Expression<?> |
ListAccessVisitor.visit(FactoryExpression<?> expr,
Context context)
|
|
Expression<?> |
CollectionAnyVisitor.visit(Operation<?> expr,
Context context)
|
|
Expression<?> |
ListAccessVisitor.visit(Operation<?> expr,
Context context)
|
|
Expression<?> |
CollectionAnyVisitor.visit(ParamExpression<?> expr,
Context context)
|
|
Expression<?> |
ListAccessVisitor.visit(ParamExpression<?> expr,
Context context)
|
|
Expression<?> |
CollectionAnyVisitor.visit(Path<?> expr,
Context context)
|
|
Expression<?> |
ListAccessVisitor.visit(Path<?> expr,
Context context)
|
|
Expression<?> |
CollectionAnyVisitor.visit(SubQueryExpression<?> expr,
Context context)
|
|
Expression<?> |
ListAccessVisitor.visit(SubQueryExpression<?> expr,
Context context)
|
|
Expression<?> |
CollectionAnyVisitor.visit(TemplateExpression<?> expr,
Context context)
|
|
Expression<?> |
ListAccessVisitor.visit(TemplateExpression<?> expr,
Context context)
|
Methods in com.mysema.query.support that return types with arguments of type Expression | |
---|---|
List<Expression<?>> |
NumberConversions.getArgs()
|
List<Expression<?>> |
NumberConversion.getArgs()
|
Methods in com.mysema.query.support with parameters of type Expression | ||
---|---|---|
void |
OrderedQueryMetadata.addJoin(JoinType joinType,
Expression<?> expr)
|
|
T |
QueryMixin.addToProjection(Expression<?>... o)
|
|
protected void |
SerializerBase.appendAsString(Expression<?> expr)
|
|
static
|
Expressions.as(Expression<D> source,
Path<D> alias)
|
|
static
|
Expressions.as(Expression<D> source,
String alias)
|
|
static BooleanExpression |
Expressions.booleanOperation(Operator<Boolean> operation,
Expression<?>... args)
|
|
static BooleanExpression |
Expressions.booleanTemplate(String template,
Expression<?>... args)
|
|
static
|
Expressions.comparableOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
|
|
static
|
Expressions.comparableTemplate(Class<T> cl,
String template,
Expression<?>... args)
|
|
Expression<?>[] |
QueryMixin.convert(Expression<?>[] exprs)
|
|
|
QueryMixin.convert(Expression<RT> expr)
|
|
protected
|
QueryMixin.createAlias(Expression<D> path,
Path<D> alias)
|
|
static
|
Expressions.dateOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
|
|
static
|
Expressions.dateTimeOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
|
|
static
|
Expressions.dslOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
|
|
static
|
Expressions.dslTemplate(Class<T> cl,
String template,
Expression<?>... args)
|
|
T |
QueryMixin.from(Expression<?>... args)
|
|
T |
QueryMixin.groupBy(Expression<?>... o)
|
|
Q |
QueryBase.groupBy(Expression<?>... o)
|
|
S |
SerializerBase.handle(Expression<?> expr)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableAdapter.iterate(Expression<?>[] args)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableAdapter.iterate(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableAdapter.iterate(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableAdapter.iterate(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableQuery.iterate(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableQuery.iterate(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableQuery.iterate(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
|
ProjectableAdapter.iterate(Expression<RT> projection)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableAdapter.iterateDistinct(Expression<?>[] args)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableQuery.iterateDistinct(Expression<?>[] args)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableAdapter.iterateDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableAdapter.iterateDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableAdapter.iterateDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableQuery.iterateDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableQuery.iterateDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
com.mysema.commons.lang.CloseableIterator<Object[]> |
ProjectableQuery.iterateDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
|
ProjectableAdapter.iterateDistinct(Expression<RT> projection)
|
|
|
ProjectableQuery.iterateDistinct(Expression<RT> projection)
|
|
ListSubQuery<Object[]> |
DetachableQuery.list(Expression<?>[] args)
|
|
List<Object[]> |
ProjectableAdapter.list(Expression<?>[] args)
|
|
List<Object[]> |
ProjectableQuery.list(Expression<?>[] args)
|
|
ListSubQuery<Object[]> |
DetachableAdapter.list(Expression<?>[] args)
|
|
ListSubQuery<Object[]> |
DetachableMixin.list(Expression<?>[] args)
|
|
ListSubQuery<Object[]> |
DetachableQuery.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
ListSubQuery<Object[]> |
DetachableQuery.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
ListSubQuery<Object[]> |
DetachableQuery.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
List<Object[]> |
ProjectableAdapter.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
List<Object[]> |
ProjectableAdapter.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
List<Object[]> |
ProjectableAdapter.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
List<Object[]> |
ProjectableQuery.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
List<Object[]> |
ProjectableQuery.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
List<Object[]> |
ProjectableQuery.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
ListSubQuery<Object[]> |
DetachableAdapter.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
ListSubQuery<Object[]> |
DetachableAdapter.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
ListSubQuery<Object[]> |
DetachableAdapter.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
ListSubQuery<Object[]> |
DetachableMixin.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
ListSubQuery<Object[]> |
DetachableMixin.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
ListSubQuery<Object[]> |
DetachableMixin.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
|
DetachableQuery.list(Expression<RT> projection)
|
|
|
ProjectableAdapter.list(Expression<RT> projection)
|
|
|
ProjectableQuery.list(Expression<RT> projection)
|
|
|
DetachableAdapter.list(Expression<RT> projection)
|
|
|
DetachableMixin.list(Expression<RT> projection)
|
|
List<Object[]> |
ProjectableAdapter.listDistinct(Expression<?>[] args)
|
|
List<Object[]> |
ProjectableQuery.listDistinct(Expression<?>[] args)
|
|
List<Object[]> |
ProjectableAdapter.listDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
List<Object[]> |
ProjectableAdapter.listDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
List<Object[]> |
ProjectableAdapter.listDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
List<Object[]> |
ProjectableQuery.listDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
List<Object[]> |
ProjectableQuery.listDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
List<Object[]> |
ProjectableQuery.listDistinct(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
|
ProjectableAdapter.listDistinct(Expression<RT> projection)
|
|
|
ProjectableQuery.listDistinct(Expression<RT> projection)
|
|
|
ProjectableAdapter.listDistinctResults(Expression<RT> expr)
|
|
|
ProjectableQuery.listDistinctResults(Expression<RT> projection)
|
|
|
ProjectableAdapter.listResults(Expression<RT> expr)
|
|
|
ProjectableAdapter.map(Expression<K> key,
Expression<V> value)
|
|
|
ProjectableAdapter.map(Expression<K> key,
Expression<V> value)
|
|
|
ProjectableQuery.map(Expression<K> key,
Expression<V> value)
|
|
|
ProjectableQuery.map(Expression<K> key,
Expression<V> value)
|
|
static
|
Expressions.numberOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
|
|
static
|
Expressions.numberTemplate(Class<T> cl,
String template,
Expression<?>... args)
|
|
static
|
Expressions.operation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
|
|
static BooleanExpression |
Expressions.predicate(Operator<Boolean> operation,
Expression<?>... args)
|
|
Object[] |
ProjectableAdapter.singleResult(Expression<?>[] args)
|
|
Object[] |
ProjectableQuery.singleResult(Expression<?>[] args)
|
|
Object[] |
ProjectableAdapter.singleResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
Object[] |
ProjectableAdapter.singleResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
Object[] |
ProjectableAdapter.singleResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
Object[] |
ProjectableQuery.singleResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
Object[] |
ProjectableQuery.singleResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
Object[] |
ProjectableQuery.singleResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
|
ProjectableAdapter.singleResult(Expression<RT> expr)
|
|
|
ProjectableQuery.singleResult(Expression<RT> expr)
|
|
static StringExpression |
Expressions.stringOperation(Operator<? super String> operator,
Expression<?>... args)
|
|
static StringExpression |
Expressions.stringTemplate(String template,
Expression<?>... args)
|
|
static
|
Expressions.template(Class<T> cl,
String template,
Expression<?>... args)
|
|
static
|
Expressions.timeOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
|
|
SimpleSubQuery<Object[]> |
DetachableQuery.unique(Expression<?>[] args)
|
|
SimpleSubQuery<Object[]> |
DetachableAdapter.unique(Expression<?>[] args)
|
|
SimpleSubQuery<Object[]> |
DetachableMixin.unique(Expression<?>[] args)
|
|
SimpleSubQuery<Object[]> |
DetachableQuery.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
SimpleSubQuery<Object[]> |
DetachableQuery.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
SimpleSubQuery<Object[]> |
DetachableQuery.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
SimpleSubQuery<Object[]> |
DetachableAdapter.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
SimpleSubQuery<Object[]> |
DetachableAdapter.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
SimpleSubQuery<Object[]> |
DetachableAdapter.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
SimpleSubQuery<Object[]> |
DetachableMixin.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
SimpleSubQuery<Object[]> |
DetachableMixin.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
SimpleSubQuery<Object[]> |
DetachableMixin.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
|
DetachableQuery.unique(Expression<RT> projection)
|
|
|
DetachableAdapter.unique(Expression<RT> projection)
|
|
|
DetachableMixin.unique(Expression<RT> projection)
|
|
Object[] |
ProjectableAdapter.uniqueResult(Expression<?>[] args)
|
|
Object[] |
ProjectableAdapter.uniqueResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
Object[] |
ProjectableAdapter.uniqueResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
Object[] |
ProjectableAdapter.uniqueResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
Object[] |
ProjectableQuery.uniqueResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
Object[] |
ProjectableQuery.uniqueResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
Object[] |
ProjectableQuery.uniqueResult(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
|
|
|
ProjectableAdapter.uniqueResult(Expression<RT> expr)
|
Method parameters in com.mysema.query.support with type arguments of type Expression | |
---|---|
protected void |
SerializerBase.visitOperation(Class<?> type,
Operator<?> operator,
List<? extends Expression<?>> args)
|
Constructors in com.mysema.query.support with parameters of type Expression | |
---|---|
NumberConversion(Expression<T> expr)
|
|
SimpleProjectableAdapter(Q query,
Expression<T> projection)
|
|
SimpleProjectableAdapter(SimpleQuery<?> query,
Projectable projectable,
Expression<T> projection)
|
Uses of Expression in com.mysema.query.types |
---|
Subinterfaces of Expression in com.mysema.query.types | |
---|---|
interface |
CollectionExpression<T extends Collection<E>,E>
CollectionExpression represents Collection typed expressions |
interface |
Constant<T>
Constant represents a general constant expression. |
interface |
EntityPath<T>
EntityPath is the common interface for entity path expressions |
interface |
FactoryExpression<T>
FactoryExpression represents factory expressions such as JavaBean or Constructor projections |
interface |
MapExpression<K,V>
MapExpression represents Map typed expressions |
interface |
Operation<T>
Operation represents an operation with operator and arguments |
interface |
ParametrizedExpression<T>
ParametrizedExpression is a common interface for expressions with generic type parameters |
interface |
ParamExpression<T>
ParamExpression defines named and unnamed parameters in queries |
interface |
Path<T>
Path represents a path expression. |
interface |
Predicate
Predicate is the common interface for Boolean typed expressions |
interface |
ProjectionRole<T>
Defines a custom projection for an Expression type. |
interface |
SubQueryExpression<T>
SubQueryExpression represents a sub query. |
interface |
TemplateExpression<T>
TemplateExpression provides base types for custom expressions with integrated serialization templates |
Classes in com.mysema.query.types that implement Expression | |
---|---|
class |
ArrayConstructorExpression<T>
ArrayConstructorExpression extends ExpressionBase to represent array initializers |
class |
ConstantImpl<T>
ConstantImpl is the default implementation of the Constant interface |
class |
ConstructorExpression<T>
ConstructorExpression represents a constructor invocation |
class |
ExpressionBase<T>
ExpressionBase is the base class for immutable Expression implementations |
static class |
FactoryExpressionUtils.FactoryExpressionAdapter<T>
|
class |
MappingProjection<T>
Projection template that allows implementing arbitrary mapping of rows to result objects. |
class |
MutableExpressionBase<T>
MutableExpressionBase is the base class for mutable Expression implementations |
class |
NullExpression<T>
NullExpression defines a general null expression |
class |
OperationImpl<T>
OperationImpl is the default implementation of the Operation interface |
class |
ParamExpressionImpl<T>
ParamExpressionImpl defines a parameter in a query with an optional name |
class |
PathImpl<T>
PathImpl defines a default implementation of the Path interface |
class |
PredicateOperation
PredicateOperation provides a Boolean typed Operation implementation |
class |
PredicateTemplate
PredicateTemplate provides a Boolean typed TemplateExpression implementation |
class |
QBean<T>
QBean is a JavaBean populating projection type |
class |
QTuple
QTuple represents a projection of type Tuple |
class |
SubQueryExpressionImpl<T>
SubQueryExpressionImpl is the default implementation of the SubQueryExpression interface |
class |
TemplateExpressionImpl<T>
Default implementation of the TemplateExpression interface |
Fields in com.mysema.query.types with type parameters of type Expression | |
---|---|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toContainsViaLike
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toContainsViaLike
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toContainsViaLikeLower
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toContainsViaLikeLower
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toEndsWithViaLike
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toEndsWithViaLike
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toEndsWithViaLikeLower
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toEndsWithViaLikeLower
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toLowerCase
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toLowerCase
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toStartsWithViaLike
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toStartsWithViaLike
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toStartsWithViaLikeLower
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toStartsWithViaLikeLower
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toUpperCase
|
com.google.common.base.Function<Expression<String>,Expression<String>> |
Converters.toUpperCase
|
Methods in com.mysema.query.types that return Expression | ||
---|---|---|
static
|
ExpressionUtils.all(CollectionExpression<?,? super T> col)
|
|
static
|
ExpressionUtils.any(CollectionExpression<?,? super T> col)
|
|
static
|
ExpressionUtils.as(Expression<D> source,
Path<D> alias)
Create an alias expression (source as alias) with the given source and alias |
|
static
|
ExpressionUtils.as(Expression<D> source,
String alias)
Create an alias expression (source as alias) with the given source and alias |
|
Expression<T> |
ConstructorExpression.as(Path<T> alias)
Create an alias for the expression |
|
Expression<T> |
QBean.as(Path<T> alias)
Create an alias for the expression |
|
Expression<T> |
ConstructorExpression.as(String alias)
Create an alias for the expression |
|
Expression<T> |
QBean.as(String alias)
Create an alias for the expression |
|
Expression<?> |
Template.Element.convert(Expression<?> source)
|
|
static Expression<Long> |
ExpressionUtils.count(Expression<?> source)
|
|
static
|
TemplateExpressionImpl.create(Class<C> cl,
String template,
Expression<?>... args)
Create a new TemplateExpression with the given template in String form and template arguments |
|
static
|
TemplateExpressionImpl.create(Class<C> cl,
Template template,
Expression<?>... args)
Create a new TemplateExpression with the given template and template arguments |
|
Expression<?> |
TemplateExpressionImpl.getArg(int index)
|
|
Expression<?> |
OperationImpl.getArg(int i)
|
|
Expression<?> |
TemplateExpression.getArg(int index)
Get the argument with the given index |
|
Expression<?> |
Operation.getArg(int index)
Get the argument with the given index |
|
Expression<T> |
PathMetadata.getExpression()
|
|
Expression<T> |
ProjectionRole.getProjection()
Return the custom projection |
|
Expression<T> |
OrderSpecifier.getTarget()
Get the target expression of this OrderSpecifier |
|
static Expression<String> |
ExpressionUtils.likeToRegex(Expression<String> expr)
Convert the given like pattern to a regex pattern |
|
static Expression<String> |
ExpressionUtils.likeToRegex(Expression<String> expr,
boolean matchStartAndEnd)
|
|
static Expression<?> |
ExpressionUtils.list(Expression<?>... exprs)
|
|
static Expression<?> |
ExpressionUtils.list(List<? extends Expression<?>> exprs)
|
|
static Expression<?> |
ExpressionUtils.merge(List<? extends Expression<?>> expressions)
|
|
static Expression<String> |
ExpressionUtils.regexToLike(Expression<String> expr)
|
|
Expression<?> |
ExtractorVisitor.visit(Constant<?> expr,
Void context)
|
|
Expression<?> |
ExtractorVisitor.visit(FactoryExpression<?> expr,
Void context)
|
|
Expression<?> |
ExtractorVisitor.visit(Operation<?> expr,
Void context)
|
|
Expression<?> |
ExtractorVisitor.visit(ParamExpression<?> expr,
Void context)
|
|
Expression<?> |
ExtractorVisitor.visit(Path<?> expr,
Void context)
|
|
Expression<?> |
ExtractorVisitor.visit(SubQueryExpression<?> expr,
Void context)
|
|
Expression<?> |
ExtractorVisitor.visit(TemplateExpression<?> expr,
Void context)
|
Methods in com.mysema.query.types that return types with arguments of type Expression | |
---|---|
List<Expression<?>> |
ArrayConstructorExpression.getArgs()
|
List<Expression<?>> |
TemplateExpressionImpl.getArgs()
|
List<Expression<?>> |
FactoryExpression.getArgs()
Get the invocation arguments |
List<Expression<?>> |
MappingProjection.getArgs()
|
List<Expression<?>> |
OperationImpl.getArgs()
|
List<Expression<?>> |
ConstructorExpression.getArgs()
|
List<Expression<?>> |
QBean.getArgs()
|
List<Expression<?>> |
FactoryExpressionUtils.FactoryExpressionAdapter.getArgs()
|
List<Expression<?>> |
TemplateExpression.getArgs()
Get the arguments of the custom expression |
List<Expression<?>> |
QTuple.getArgs()
|
List<Expression<?>> |
Operation.getArgs()
Get the arguments of this operation |
Methods in com.mysema.query.types with parameters of type Expression | ||
---|---|---|
static
|
Projections.array(Class<T[]> type,
Expression<T>... exprs)
Create a typed array projection for the given type and expressions |
|
static
|
ExpressionUtils.as(Expression<D> source,
Path<D> alias)
Create an alias expression (source as alias) with the given source and alias |
|
static
|
ExpressionUtils.as(Expression<D> source,
String alias)
Create an alias expression (source as alias) with the given source and alias |
|
static
|
Projections.bean(Class<T> type,
Expression<?>... exprs)
Create a Bean populating projection for the given type and expressions |
|
static
|
Projections.bean(Path<T> type,
Expression<?>... exprs)
Create a Bean populating projection for the given type and expressions |
|
static
|
Projections.constructor(Class<T> type,
Expression<?>... exprs)
Create a constructor invocation projection for the given type and expressions |
|
Expression<?> |
Template.Element.convert(Expression<?> source)
|
|
static Expression<Long> |
ExpressionUtils.count(Expression<?> source)
|
|
static
|
OperationImpl.create(Class<? extends RT> type,
Operator<? super RT> operator,
Expression<?>... args)
|
|
static
|
TemplateExpressionImpl.create(Class<C> cl,
String template,
Expression<?>... args)
Create a new TemplateExpression with the given template in String form and template arguments |
|
static
|
TemplateExpressionImpl.create(Class<C> cl,
Template template,
Expression<?>... args)
Create a new TemplateExpression with the given template and template arguments |
|
static
|
ConstructorExpression.create(Class<D> type,
Expression<?>... args)
|
|
static
|
ExpressionUtils.eq(Expression<D> left,
Expression<? extends D> right)
Create an left equals right expression |
|
static
|
ExpressionUtils.eq(Expression<D> left,
Expression<? extends D> right)
Create an left equals right expression |
|
static
|
ExpressionUtils.eqConst(Expression<D> left,
D constant)
Create an left equals constant expression |
|
static
|
Projections.fields(Class<T> type,
Expression<?>... exprs)
Create a field access based Bean populating projection for the given type and expressions |
|
static
|
Projections.fields(Path<T> type,
Expression<?>... exprs)
Create a field access based Bean populating projection for the given type and expressions |
|
static PathMetadata<Integer> |
PathMetadataFactory.forArrayAccess(Path<?> parent,
Expression<Integer> index)
Create a new PathMetadata for indexed array access |
|
static PathMetadata<Integer> |
PathMetadataFactory.forListAccess(Path<?> parent,
Expression<Integer> index)
Create a new PathMetadata for indexed list access |
|
static
|
PathMetadataFactory.forMapAccess(Path<?> parent,
Expression<KT> key)
Create a new PathMetadata for key based map access |
|
static
|
ExpressionUtils.in(Expression<D> left,
Collection<? extends D> right)
Create an left in right expression |
|
static
|
ExpressionUtils.in(Expression<D> left,
CollectionExpression<?,? extends D> right)
Create an left in right expression |
|
static Predicate |
ExpressionUtils.isNotNull(Expression<?> left)
Create a left is not null expression |
|
static Predicate |
ExpressionUtils.isNull(Expression<?> left)
Create a left is null expression |
|
static Expression<String> |
ExpressionUtils.likeToRegex(Expression<String> expr)
Convert the given like pattern to a regex pattern |
|
static Expression<String> |
ExpressionUtils.likeToRegex(Expression<String> expr,
boolean matchStartAndEnd)
|
|
static Expression<?> |
ExpressionUtils.list(Expression<?>... exprs)
|
|
static
|
ExpressionUtils.ne(Expression<D> left,
Expression<? super D> right)
Create a left not equals right expression |
|
static
|
ExpressionUtils.ne(Expression<D> left,
Expression<? super D> right)
Create a left not equals right expression |
|
static
|
ExpressionUtils.neConst(Expression<D> left,
D constant)
Create a left not equals constant expression |
|
static Expression<String> |
ExpressionUtils.regexToLike(Expression<String> expr)
|
|
static QTuple |
Projections.tuple(Expression<?>... exprs)
Create a Tuple typed projection for the given expressions |
Method parameters in com.mysema.query.types with type arguments of type Expression | |
---|---|
static Expression<?> |
ExpressionUtils.list(List<? extends Expression<?>> exprs)
|
static Expression<?> |
ExpressionUtils.merge(List<? extends Expression<?>> expressions)
|
static FactoryExpression<?> |
FactoryExpressionUtils.wrap(List<? extends Expression<?>> projection)
|
Constructors in com.mysema.query.types with parameters of type Expression | |
---|---|
ArrayConstructorExpression(Class<T[]> type,
Expression<T>... args)
|
|
ArrayConstructorExpression(Expression<?>... args)
|
|
ConstructorExpression(Class<T> type,
Class<?>[] paramTypes,
Expression<?>... args)
|
|
MappingProjection(Class<? super T> type,
Expression<?>... args)
Create a new MappingProjection instance |
|
MappingProjection(Class<? super T> type,
Expression<?>[]... args)
Create a new MappingProjection instance |
|
OperationImpl(Class<? extends T> type,
Operator<? super T> operator,
Expression<?>... args)
|
|
OrderSpecifier(Order order,
Expression<T> target)
|
|
PathMetadata(Path<?> parent,
Expression<T> expression,
PathType type)
|
|
PredicateOperation(Operator<Boolean> operator,
Expression<?>... args)
|
|
PredicateTemplate(String template,
Expression<?>... args)
|
|
PredicateTemplate(Template template,
Expression<?>... args)
|
|
QBean(Class<T> type,
boolean fieldAccess,
Expression<?>... args)
Create a new QBean instance |
|
QBean(Class<T> type,
Expression<?>... args)
Create a new QBean instance |
|
QBean(Path<T> type,
boolean fieldAccess,
Expression<?>... args)
Create a new QBean instance |
|
QBean(Path<T> type,
Expression<?>... args)
Create a new QBean instance |
|
QTuple(Expression<?>... args)
Create a new QTuple instance |
|
QTuple(Expression<?>[]... args)
Create a new QTuple instance |
|
TemplateExpressionImpl(Class<? extends T> type,
Template template,
Expression<?>... args)
|
Constructor parameters in com.mysema.query.types with type arguments of type Expression | |
---|---|
ConstructorExpression(Class<T> type,
Class<?>[] paramTypes,
List<Expression<?>> args)
|
|
OperationImpl(Class<? extends T> type,
Operator<? super T> operator,
List<Expression<?>> args)
|
|
PredicateOperation(Operator<Boolean> operator,
List<Expression<?>> args)
|
|
PredicateTemplate(Template template,
List<Expression<?>> args)
|
|
QBean(Class<T> type,
boolean fieldAccess,
Map<String,? extends Expression<?>> bindings)
Create a new QBean instance |
|
QBean(Class<T> type,
Map<String,? extends Expression<?>> bindings)
Create a new QBean instance |
|
QBean(Path<T> type,
boolean fieldAccess,
Map<String,? extends Expression<?>> bindings)
Create a new QBean instance |
|
QBean(Path<T> type,
Map<String,? extends Expression<?>> bindings)
Create a new QBean instance |
|
TemplateExpressionImpl(Class<? extends T> type,
Template template,
List<Expression<?>> args)
|
|
ValidatingVisitor(Collection<Expression<?>> known)
|
Uses of Expression in com.mysema.query.types.expr |
---|
Classes in com.mysema.query.types.expr with type parameters of type Expression | |
---|---|
static class |
CaseBuilder.Cases<A,Q extends Expression<A>>
Cascading typesafe Case builder |
static class |
CaseBuilder.CaseWhen<A,Q extends Expression<A>>
Intermediate When state |
class |
CaseForEqBuilder.Cases<T,Q extends Expression<T>>
|
class |
CaseForEqBuilder.CaseWhen<T,Q extends Expression<T>>
|
Subinterfaces of Expression in com.mysema.query.types.expr | |
---|---|
interface |
ArrayExpression<T>
ArrayExpression defines an interface for array typed expression |
interface |
ListExpression<E,Q extends SimpleExpression<? super E>>
ListExpression represents List typed expressions |
Classes in com.mysema.query.types.expr that implement Expression | |
---|---|
class |
BooleanExpression
BooleanExpression represents Boolean expressions |
class |
BooleanOperation
BooleanOperation represents boolean operations |
class |
Coalesce<T extends Comparable>
Coalesce defines a coalesce function invocation. |
class |
CollectionExpressionBase<T extends Collection<E>,E>
CollectionExpressionBase is an abstract base class for CollectionExpression implementations |
class |
ComparableExpression<T extends Comparable>
ComparableExpression extends ComparableExpressionBase to provide comparison methods. |
class |
ComparableExpressionBase<T extends Comparable>
ComparableExpressionBase represents comparable expressions |
class |
ComparableOperation<T extends Comparable<?>>
ComparableOperation represents Comparable operations |
class |
DateExpression<T extends Comparable>
DateExpression represents Date expressions The date representation is compatible with the Gregorian calendar. |
class |
DateOperation<T extends Comparable<?>>
DateOperation represents Date operations |
class |
DateTimeExpression<T extends Comparable>
DateTimeExpression represents Date / Time expressions The date representation is compatible with the Gregorian calendar. |
class |
DateTimeOperation<T extends Comparable<?>>
DateTimeOperation represents DateTime operations |
class |
DslExpression<T>
DslExpression is the base class for DSL expressions, but SimpleExpression is the base class
for scalar Expressions |
class |
DslOperation<T>
DslOperation represents a simple operation expression |
class |
EnumExpression<T extends Enum<T>>
EnumExpression represents Enum typed expressions |
class |
EnumOperation<T extends Enum<T>>
EnumOperation represents enum operations |
class |
MapExpressionBase<K,V,Q extends SimpleExpression<? super V>>
MapExpressionBase is an abstract base class for MapExpression implementations |
class |
NumberExpression<T extends Number & Comparable<?>>
NumberExpression represents a numeric expression |
class |
NumberOperation<T extends Number & Comparable<?>>
NumberOperation represents numeric operations |
class |
Param<T>
Param defines a parameter in a query with an optional name |
class |
SimpleExpression<T>
SimpleExpression is the base class for Expression implementations. |
class |
SimpleOperation<T>
SimpleOperation represents a simple operation expression |
class |
StringExpression
StringExpression represents String expressions |
class |
StringOperation
StringOperation represents a String typed operation |
class |
TemporalExpression<T extends Comparable>
TemporalExpression is a supertype for Date/Time related types |
class |
TimeExpression<T extends Comparable>
TimeExpression represents Time expressions |
class |
TimeOperation<T extends Comparable<?>>
TimeOperation represents Time operations |
Fields in com.mysema.query.types.expr declared as Expression | |
---|---|
static Expression<Object[]> |
Wildcard.all
|
protected Expression<T> |
DslExpression.mixin
|
Methods in com.mysema.query.types.expr that return Expression | |
---|---|
Expression<?> |
DateOperation.getArg(int index)
|
Expression<?> |
DateTimeOperation.getArg(int index)
|
Expression<?> |
TimeOperation.getArg(int index)
|
Expression<?> |
NumberOperation.getArg(int index)
|
Expression<?> |
EnumOperation.getArg(int index)
|
Expression<?> |
StringOperation.getArg(int index)
|
Expression<?> |
BooleanOperation.getArg(int index)
|
Expression<?> |
SimpleOperation.getArg(int index)
|
Expression<?> |
ComparableOperation.getArg(int index)
|
Expression<?> |
DslOperation.getArg(int index)
|
Methods in com.mysema.query.types.expr that return types with arguments of type Expression | ||
---|---|---|
List<Expression<?>> |
DateOperation.getArgs()
|
|
List<Expression<?>> |
DateTimeOperation.getArgs()
|
|
List<Expression<?>> |
TimeOperation.getArgs()
|
|
List<Expression<?>> |
NumberOperation.getArgs()
|
|
List<Expression<?>> |
EnumOperation.getArgs()
|
|
List<Expression<?>> |
StringOperation.getArgs()
|
|
List<Expression<?>> |
BooleanOperation.getArgs()
|
|
List<Expression<?>> |
SimpleOperation.getArgs()
|
|
List<Expression<?>> |
ComparableOperation.getArgs()
|
|
List<Expression<?>> |
DslOperation.getArgs()
|
|
|
CaseBuilder.Initial.then(A constant)
|
|
|
CaseBuilder.Initial.then(Expression<A> expr)
|
|
|
CaseForEqBuilder.then(Expression<T> then)
|
|
|
CaseForEqBuilder.then(T then)
|
|
|
CaseForEqBuilder.thenNull()
|
Methods in com.mysema.query.types.expr with parameters of type Expression | ||
---|---|---|
static
|
MathExpressions.acos(Expression<A> num)
|
|
|
NumberExpression.add(Expression<N> right)
Get the sum of this and right |
|
Coalesce<T> |
Coalesce.add(Expression<T> expr)
|
|
BooleanExpression |
TemporalExpression.after(Expression<T> right)
Get a this > right expression |
|
StringExpression |
StringExpression.append(Expression<String> str)
Get the concatenation of this and str |
|
static
|
MathExpressions.asin(Expression<A> num)
|
|
static
|
MathExpressions.atan(Expression<A> num)
|
|
BooleanExpression |
TemporalExpression.before(Expression<T> right)
Get a this < right expression |
|
|
NumberExpression.between(Expression<A> from,
Expression<A> to)
Create a from < this < to expression |
|
|
NumberExpression.between(Expression<A> from,
Expression<A> to)
Create a from < this < to expression |
|
BooleanExpression |
ComparableExpression.between(Expression<T> from,
Expression<T> to)
Get a first <= this <= second expression |
|
BooleanExpression |
ComparableExpression.between(Expression<T> from,
Expression<T> to)
Get a first <= this <= second expression |
|
SimpleExpression<Character> |
StringExpression.charAt(Expression<Integer> i)
Get the character at the given index |
|
Coalesce<T> |
ComparableExpressionBase.coalesce(Expression<?>... exprs)
|
|
StringExpression |
StringExpression.concat(Expression<String> str)
Get the concatenation of this and str |
|
BooleanExpression |
CollectionExpressionBase.contains(Expression<E> child)
|
|
BooleanExpression |
MapExpressionBase.contains(Expression<K> key,
Expression<V> value)
|
|
BooleanExpression |
MapExpressionBase.contains(Expression<K> key,
Expression<V> value)
|
|
BooleanExpression |
StringExpression.contains(Expression<String> str)
Returns true if the given String is contained |
|
BooleanExpression |
StringExpression.containsIgnoreCase(Expression<String> str)
|
|
BooleanExpression |
MapExpressionBase.containsKey(Expression<K> key)
|
|
BooleanExpression |
MapExpressionBase.containsValue(Expression<V> value)
|
|
static
|
MathExpressions.cos(Expression<A> num)
|
|
static
|
MathExpressions.cosh(Expression<A> num)
|
|
static
|
MathExpressions.cot(Expression<A> num)
|
|
static
|
MathExpressions.coth(Expression<A> num)
|
|
static
|
EnumOperation.create(Class<? extends D> type,
Operator<? super D> op,
Expression<?>... args)
Factory method |
|
static
|
NumberOperation.create(Class<? extends D> type,
Operator<? super D> op,
Expression<?>... args)
Factory method |
|
static
|
SimpleOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args)
Factory method |
|
static
|
DslOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args)
Factory method |
|
static
|
DateOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args)
Factory method |
|
static
|
DateTimeOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args)
Factory method |
|
static
|
TimeOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args)
Factory method |
|
static
|
ComparableOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args)
Factory method |
|
static BooleanExpression |
BooleanOperation.create(Operator<? super Boolean> op,
Expression<?>... args)
|
|
static StringExpression |
StringOperation.create(Operator<? super String> op,
Expression<?>... args)
|
|
protected abstract Q |
CaseBuilder.Cases.createResult(Class<A> type,
Expression<A> last)
|
|
protected abstract Q |
CaseForEqBuilder.Cases.createResult(Class<T> type,
Expression<T> last)
|
|
static
|
MathExpressions.degrees(Expression<A> num)
|
|
|
NumberExpression.divide(Expression<N> right)
Get the result of the operation this / right |
|
BooleanExpression |
StringExpression.endsWith(Expression<String> str)
Returns true if this ends with str |
|
BooleanExpression |
StringExpression.endsWithIgnoreCase(Expression<String> str)
|
|
BooleanExpression |
SimpleExpression.eq(Expression<? super T> right)
Get a this == right expression |
|
BooleanExpression |
StringExpression.equalsIgnoreCase(Expression<String> str)
Compares this StringExpression to another StringExpression , ignoring case
considerations. |
|
static
|
MathExpressions.exp(Expression<A> num)
|
|
Q |
ListExpression.get(Expression<Integer> index)
Indexed access |
|
SimpleExpression<T> |
ArrayExpression.get(Expression<Integer> index)
Get the element at the given index |
|
abstract Q |
MapExpressionBase.get(Expression<K> key)
|
|
|
NumberExpression.goe(Expression<A> right)
Create a this >= right expression |
|
BooleanExpression |
ComparableExpression.goe(Expression<T> right)
Get a this >= right expression |
|
|
NumberExpression.gt(Expression<A> right)
Create a this > right expression |
|
BooleanExpression |
ComparableExpression.gt(Expression<T> right)
Get a this > right expression |
|
NumberExpression<Integer> |
StringExpression.indexOf(Expression<String> str)
Get the index of the given substring in this String |
|
NumberExpression<Integer> |
StringExpression.indexOf(Expression<String> str,
int i)
Get the index of the given substring in this String, starting from the given index |
|
BooleanExpression |
StringExpression.like(Expression<String> str)
Expr: this like str |
|
BooleanExpression |
NumberExpression.like(Expression<String> str)
Expr: this like str |
|
BooleanExpression |
StringExpression.like(Expression<String> str,
char escape)
Expr: this like str |
|
static
|
MathExpressions.ln(Expression<A> num)
|
|
NumberExpression<Integer> |
StringExpression.locate(Expression<String> str)
Get the position of the given String in this String, the first position is 1 |
|
NumberExpression<Integer> |
StringExpression.locate(Expression<String> str,
NumberExpression<Integer> start)
Get the position of the given String in this String, the first position is 1 |
|
|
NumberExpression.loe(Expression<A> right)
Create a this <= right expression |
|
BooleanExpression |
ComparableExpression.loe(Expression<T> right)
Get a this < right expression |
|
static
|
MathExpressions.log(Expression<A> num,
int base)
|
|
static StringExpression |
StringExpressions.lpad(Expression<String> in,
Expression<Integer> length)
|
|
static StringExpression |
StringExpressions.lpad(Expression<String> in,
Expression<Integer> length)
|
|
static StringExpression |
StringExpressions.lpad(Expression<String> in,
int length)
|
|
static StringExpression |
StringExpressions.lpad(Expression<String> in,
int length,
char c)
|
|
static StringExpression |
StringExpressions.lpad(Expression<String> in,
NumberExpression<Integer> length,
char c)
|
|
|
NumberExpression.lt(Expression<A> right)
Create a this < right expression |
|
BooleanExpression |
ComparableExpression.lt(Expression<T> right)
Get a this < right expression |
|
static StringExpression |
StringExpressions.ltrim(Expression<String> str)
|
|
BooleanExpression |
StringExpression.matches(Expression<String> regex)
Return true if this String matches the given regular expression |
|
static
|
MathExpressions.max(Expression<A> left,
Expression<A> right)
Return the greater of the given values |
|
static
|
MathExpressions.max(Expression<A> left,
Expression<A> right)
Return the greater of the given values |
|
static
|
NumberExpression.max(Expression<A> left,
Expression<A> right)
Return the greater of the given values |
|
static
|
NumberExpression.max(Expression<A> left,
Expression<A> right)
Return the greater of the given values |
|
static
|
MathExpressions.min(Expression<A> left,
Expression<A> right)
Return the smaller of the given values |
|
static
|
MathExpressions.min(Expression<A> left,
Expression<A> right)
Return the smaller of the given values |
|
static
|
NumberExpression.min(Expression<A> left,
Expression<A> right)
Return the smaller of the given values |
|
static
|
NumberExpression.min(Expression<A> left,
Expression<A> right)
Return the smaller of the given values |
|
NumberExpression<T> |
NumberExpression.mod(Expression<T> num)
|
|
|
NumberExpression.multiply(Expression<N> right)
Get the result of the operation this * right |
|
BooleanExpression |
SimpleExpression.ne(Expression<? super T> right)
Get a this <> right expression |
|
|
NumberExpression.notBetween(Expression<A> from,
Expression<A> to)
|
|
|
NumberExpression.notBetween(Expression<A> from,
Expression<A> to)
|
|
BooleanExpression |
ComparableExpression.notBetween(Expression<T> from,
Expression<T> to)
Get a this not between from and to expression |
|
BooleanExpression |
ComparableExpression.notBetween(Expression<T> from,
Expression<T> to)
Get a this not between from and to expression |
|
BooleanExpression |
StringExpression.notEqualsIgnoreCase(Expression<String> str)
Compares this StringExpression to another StringExpression , ignoring case
considerations. |
|
BooleanExpression |
StringExpression.notLike(Expression<String> str)
Expr: this not like str |
|
BooleanExpression |
StringExpression.notLike(Expression<String> str,
char escape)
Expr: this not like str |
|
Q |
CaseBuilder.Cases.otherwise(Expression<A> expr)
|
|
Q |
CaseForEqBuilder.Cases.otherwise(Expression<T> otherwise)
|
|
static
|
MathExpressions.power(Expression<A> num,
int exponent)
|
|
StringExpression |
StringExpression.prepend(Expression<String> str)
Prepend the given String and return the result |
|
static
|
MathExpressions.radians(Expression<A> num)
|
|
static StringExpression |
StringExpressions.rpad(Expression<String> in,
Expression<Integer> length)
|
|
static StringExpression |
StringExpressions.rpad(Expression<String> in,
Expression<Integer> length)
|
|
static StringExpression |
StringExpressions.rpad(Expression<String> in,
int length)
|
|
static StringExpression |
StringExpressions.rpad(Expression<String> in,
int length,
char c)
|
|
static StringExpression |
StringExpressions.rpad(Expression<String> in,
NumberExpression<Integer> length,
char c)
|
|
static StringExpression |
StringExpressions.rtrim(Expression<String> str)
|
|
static
|
MathExpressions.sign(Expression<A> num)
|
|
static
|
MathExpressions.sin(Expression<A> num)
|
|
static
|
MathExpressions.sinh(Expression<A> num)
|
|
BooleanExpression |
StringExpression.startsWith(Expression<String> str)
Return true if this starts with str |
|
BooleanExpression |
StringExpression.startsWithIgnoreCase(Expression<String> str)
|
|
StringExpression |
StringExpression.substring(Expression<Integer> beginIndex)
Get the given substring |
|
StringExpression |
StringExpression.substring(Expression<Integer> beginIndex,
Expression<Integer> endIndex)
Get the given substring |
|
StringExpression |
StringExpression.substring(Expression<Integer> beginIndex,
Expression<Integer> endIndex)
Get the given substring |
|
StringExpression |
StringExpression.substring(Expression<Integer> beginIndex,
int endIndex)
Get the given substring |
|
StringExpression |
StringExpression.substring(int beginIndex,
Expression<Integer> endIndex)
Get the given substring |
|
|
NumberExpression.subtract(Expression<N> right)
Get the difference of this and right |
|
static
|
MathExpressions.tan(Expression<A> num)
|
|
static
|
MathExpressions.tanh(Expression<A> num)
|
|
CaseBuilder.Cases<A,Q> |
CaseBuilder.CaseWhen.then(Expression<A> expr)
|
|
|
CaseBuilder.Initial.then(Expression<A> expr)
|
|
CaseForEqBuilder.Cases<T,Q> |
CaseForEqBuilder.CaseWhen.then(Expression<T> then)
|
|
|
CaseForEqBuilder.then(Expression<T> then)
|
|
|
CaseForEqBuilder.thenNumber(Expression<T> then)
|
|
CaseForEqBuilder.CaseWhen<T,Q> |
CaseForEqBuilder.Cases.when(Expression<? extends D> when)
|
|
CaseForEqBuilder<T> |
SimpleExpression.when(Expression<? extends T> other)
Get a case expression builder |
Constructor parameters in com.mysema.query.types.expr with type arguments of type Expression | |
---|---|
BooleanOperation(Operator<? super Boolean> op,
List<Expression<?>> args)
|
|
ComparableOperation(Class<T> type,
Operator<? super T> op,
List<Expression<?>> args)
|
|
DateOperation(Class<T> type,
Operator<? super T> op,
List<Expression<?>> args)
|
|
DateTimeOperation(Class<T> type,
Operator<? super T> op,
List<Expression<?>> args)
|
|
DslOperation(Class<T> type,
Operator<? super T> op,
List<Expression<?>> args)
|
|
EnumOperation(Class<? extends T> type,
Operator<? super T> op,
List<Expression<?>> args)
|
|
NumberOperation(Class<? extends T> type,
Operator<? super T> op,
List<Expression<?>> args)
|
|
SimpleOperation(Class<T> type,
Operator<? super T> op,
List<Expression<?>> args)
|
|
StringOperation(Operator<? super String> op,
List<Expression<?>> args)
|
|
TimeOperation(Class<T> type,
Operator<? super T> op,
List<Expression<?>> args)
|
Uses of Expression in com.mysema.query.types.path |
---|
Classes in com.mysema.query.types.path that implement Expression | |
---|---|
class |
ArrayPath<E>
ArrayPath represents an array typed path |
class |
BeanPath<T>
BeanPath represents bean paths |
class |
BooleanPath
BooleanPath represents boolean path expressions |
class |
CollectionPath<E,Q extends SimpleExpression<? super E>>
CollectionPath represents collection paths |
class |
CollectionPathBase<C extends Collection<E>,E,Q extends SimpleExpression<? super E>>
CollectionPath is a base class for collection typed paths |
class |
ComparableEntityPath<T extends Comparable>
ComparableEntityPath extends the ComparablePath class to implement the EntityPath interface |
class |
ComparablePath<T extends Comparable>
ComparablePath represents Comparable paths |
class |
DatePath<T extends Comparable>
DatePath presents Date paths |
class |
DateTimePath<T extends Comparable>
DateTimePath presents DateTime typed paths |
class |
DslPath<T>
DslPath represents simple paths |
class |
EntityPathBase<T>
EntityPathBase provides a base class for EntityPath implementations |
class |
EnumPath<T extends Enum<T>>
EnumPath represents enum paths |
class |
ListPath<E,Q extends SimpleExpression<? super E>>
ListPath represents list paths |
class |
MapPath<K,V,E extends SimpleExpression<? super V>>
MapPath represents map paths |
class |
NumberPath<T extends Number & Comparable<?>>
NumberPath represents numeric paths |
class |
PathBuilder<T>
PathBuilder is an extension to EntityPathBase for dynamic path construction |
class |
SetPath<E,Q extends SimpleExpression<? super E>>
SetPath represents set paths |
class |
SimplePath<T>
SimplePath represents simple paths |
class |
StringPath
StringPath represents String typed paths |
class |
TimePath<T extends Comparable>
TimePath represented Time paths |
Methods in com.mysema.query.types.path with parameters of type Expression | |
---|---|
protected PathMetadata<Integer> |
ListPath.forListAccess(Expression<Integer> index)
|
protected PathMetadata<K> |
MapPath.forMapAccess(Expression<K> key)
|
SimplePath<E> |
ArrayPath.get(Expression<Integer> index)
Create a expression for indexed access |
Q |
ListPath.get(Expression<Integer> index)
|
E |
MapPath.get(Expression<K> key)
|
Uses of Expression in com.mysema.query.types.query |
---|
Subinterfaces of Expression in com.mysema.query.types.query | |
---|---|
interface |
ExtendedSubQueryExpression<T>
Extensions to the SubQueryExpression interface |
Classes in com.mysema.query.types.query that implement Expression | |
---|---|
class |
BooleanSubQuery
Boolean typed single result subquery |
class |
ComparableSubQuery<T extends Comparable<?>>
Comparable typed single result subquery |
class |
DateSubQuery<T extends Comparable<?>>
Date typed single result subquery |
class |
DateTimeSubQuery<T extends Comparable<?>>
DateTime typed single result subquery |
class |
ListSubQuery<T>
List result subquery |
class |
NumberSubQuery<T extends Number & Comparable<?>>
Number typed single result subquery |
class |
SimpleSubQuery<T>
Object typed single result subquery |
class |
StringSubQuery
String typed single result subquery |
class |
TimeSubQuery<T extends Comparable<?>>
Time typed single result subquery |
Methods in com.mysema.query.types.query with parameters of type Expression | ||
---|---|---|
SimpleExpression<?> |
ListSubQuery.as(Expression<?> alias)
|
|
ListSubQuery<Object[]> |
Detachable.list(Expression<?>[] args)
Create a projection expression for the given projection |
|
ListSubQuery<Object[]> |
Detachable.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
Create a projection expression for the given projection |
|
ListSubQuery<Object[]> |
Detachable.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
Create a projection expression for the given projection |
|
ListSubQuery<Object[]> |
Detachable.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
Create a projection expression for the given projection |
|
|
Detachable.list(Expression<RT> projection)
Create a projection expression for the given projection |
|
SimpleSubQuery<Object[]> |
Detachable.unique(Expression<?>[] args)
Create a projection expression for the given projection |
|
SimpleSubQuery<Object[]> |
Detachable.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
Create a projection expression for the given projection |
|
SimpleSubQuery<Object[]> |
Detachable.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
Create a projection expression for the given projection |
|
SimpleSubQuery<Object[]> |
Detachable.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest)
Create a projection expression for the given projection |
|
|
Detachable.unique(Expression<RT> projection)
Create a subquery expression for the given projection |
Uses of Expression in com.mysema.query.types.template |
---|
Classes in com.mysema.query.types.template that implement Expression | |
---|---|
class |
BooleanTemplate
BooleanTemplate is a custom boolean expression |
class |
ComparableTemplate<T extends Comparable<?>>
ComparableTemplate defines custom comparable expressions |
class |
DateTemplate<T extends Comparable<?>>
DateTemplate defines custom date expressions |
class |
DateTimeTemplate<T extends Comparable<?>>
DateTimeTemplate defines custom dateTime expressions |
class |
DslTemplate<T>
DslTemplate defines custom simple expressions |
class |
EnumTemplate<T extends Enum<T>>
EnumTemplate defines custom enum expressions |
class |
NumberTemplate<T extends Number & Comparable<?>>
NumberTemplate defines custom numeric expressions |
class |
SimpleTemplate<T>
SimpleTemplate defines custom simple expressions |
class |
StringTemplate
StringTemplate defines custom String expressions |
class |
TimeTemplate<T extends Comparable<?>>
TimeTemplate defines custom time expressions |
Methods in com.mysema.query.types.template that return Expression | |
---|---|
Expression<?> |
TimeTemplate.getArg(int index)
|
Expression<?> |
BooleanTemplate.getArg(int index)
|
Expression<?> |
EnumTemplate.getArg(int index)
|
Expression<?> |
DateTimeTemplate.getArg(int index)
|
Expression<?> |
ComparableTemplate.getArg(int index)
|
Expression<?> |
StringTemplate.getArg(int index)
|
Expression<?> |
NumberTemplate.getArg(int index)
|
Expression<?> |
DateTemplate.getArg(int index)
|
Expression<?> |
DslTemplate.getArg(int index)
|
Expression<?> |
SimpleTemplate.getArg(int index)
|
Methods in com.mysema.query.types.template that return types with arguments of type Expression | |
---|---|
List<Expression<?>> |
TimeTemplate.getArgs()
|
List<Expression<?>> |
BooleanTemplate.getArgs()
|
List<Expression<?>> |
EnumTemplate.getArgs()
|
List<Expression<?>> |
DateTimeTemplate.getArgs()
|
List<Expression<?>> |
ComparableTemplate.getArgs()
|
List<Expression<?>> |
StringTemplate.getArgs()
|
List<Expression<?>> |
NumberTemplate.getArgs()
|
List<Expression<?>> |
DateTemplate.getArgs()
|
List<Expression<?>> |
DslTemplate.getArgs()
|
List<Expression<?>> |
SimpleTemplate.getArgs()
|
Methods in com.mysema.query.types.template with parameters of type Expression | ||
---|---|---|
static
|
DslTemplate.create(Class<? extends T> type,
String template,
Expression<?>... args)
|
|
static
|
SimpleTemplate.create(Class<? extends T> type,
String template,
Expression<?>... args)
|
|
static
|
DslTemplate.create(Class<? extends T> type,
Template template,
Expression<?>... args)
|
|
static
|
SimpleTemplate.create(Class<? extends T> type,
Template template,
Expression<?>... args)
|
|
static
|
TimeTemplate.create(Class<T> type,
String template,
Expression<?>... args)
|
|
static
|
DateTimeTemplate.create(Class<T> type,
String template,
Expression<?>... args)
|
|
static
|
ComparableTemplate.create(Class<T> type,
String template,
Expression<?>... args)
|
|
static
|
DateTemplate.create(Class<T> type,
String template,
Expression<?>... args)
|
|
static
|
EnumTemplate.create(Class<T> type,
String template,
Expression<?>... args)
|
|
static
|
NumberTemplate.create(Class<T> type,
String template,
Expression<?>... args)
|
|
static
|
TimeTemplate.create(Class<T> type,
Template template,
Expression<?>... args)
|
|
static
|
DateTimeTemplate.create(Class<T> type,
Template template,
Expression<?>... args)
|
|
static
|
ComparableTemplate.create(Class<T> type,
Template template,
Expression<?>... args)
|
|
static
|
DateTemplate.create(Class<T> type,
Template template,
Expression<?>... args)
|
|
static
|
EnumTemplate.create(Class<T> type,
Template template,
Expression<?>... args)
|
|
static
|
NumberTemplate.create(Class<T> type,
Template template,
Expression<?>... args)
|
|
static BooleanExpression |
BooleanTemplate.create(String template,
Expression<?>... args)
|
|
static StringExpression |
StringTemplate.create(String template,
Expression<?>... args)
|
|
static BooleanExpression |
BooleanTemplate.create(Template template,
Expression<?>... args)
|
|
static StringExpression |
StringTemplate.create(Template template,
Expression<?>... args)
|
Constructor parameters in com.mysema.query.types.template with type arguments of type Expression | |
---|---|
BooleanTemplate(Template template,
List<Expression<?>> args)
|
|
ComparableTemplate(Class<T> type,
Template template,
List<Expression<?>> args)
|
|
DateTemplate(Class<T> type,
Template template,
List<Expression<?>> args)
|
|
DateTimeTemplate(Class<T> type,
Template template,
List<Expression<?>> args)
|
|
DslTemplate(Class<? extends T> type,
Template template,
List<Expression<?>> args)
|
|
EnumTemplate(Class<T> type,
Template template,
List<Expression<?>> args)
|
|
NumberTemplate(Class<T> type,
Template template,
List<Expression<?>> args)
|
|
SimpleTemplate(Class<? extends T> type,
Template template,
List<Expression<?>> args)
|
|
StringTemplate(Template template,
List<Expression<?>> args)
|
|
TimeTemplate(Class<T> type,
Template template,
List<Expression<?>> args)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |