|
||||||||||
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 | APTFactory and 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.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 | HQL Support classes |
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<? extends Expression<?>> |
QueryMetadata.getGroupBy()
Get the group by expressions |
List<? extends Expression<?>> |
DefaultQueryMetadata.getGroupBy()
|
List<? extends Expression<?>> |
QueryMetadata.getProjection()
Get the projection |
List<? extends 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 |
DefaultQueryMetadata.addGroupBy(Expression<?>... o)
|
|
void |
QueryMetadata.addJoin(JoinType joinType,
Expression<?> expr)
Add the given query join |
|
void |
DefaultQueryMetadata.addJoin(JoinType joinType,
Expression<?> expr)
|
|
void |
QueryMetadata.addProjection(Expression<?>... o)
Add the given projections |
|
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)
|
|
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)
|
|
|
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 |
|
void |
AliasFactory.setCurrent(Expression<?> expr)
Set the thread bound expression to the given value |
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)
|
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<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.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<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 | ||
---|---|---|
static
|
JPQLGrammar.all(CollectionExpression<?,D> col)
|
|
static
|
JPQLGrammar.any(CollectionExpression<?,D> col)
|
|
static
|
JPQLGrammar.some(CollectionExpression<?,D> col)
|
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)
|
|
T |
AbstractSQLQuery.from(Expression<?>... args)
|
|
static
|
JPQLGrammar.sum(Expression<D> left)
SUM returns Long when applied to state-fields of integral types (other than BigInteger); Double when applied to state-fields of floating point types; BigInteger when applied to state-fields of type BigInteger; and BigDecimal when applied to state-fields of type BigDecimal. |
|
static
|
JPQLGrammar.sumAsDouble(Expression<D> left)
|
|
static
|
JPQLGrammar.sumAsLong(Expression<D> left)
|
Method parameters in com.mysema.query.jpa with type arguments of type Expression | |
---|---|
protected void |
JPQLSerializer.visitOperation(Class<?> type,
Operator<?> operator,
List<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 |
RelationalPathBase<T>
RelationalPathBase is a base class for RelationPath implements |
Methods in com.mysema.query.sql that return Expression | |
---|---|
Expression<?> |
SQLSubQuery.union(SubQueryExpression<?>... sq)
|
Methods in com.mysema.query.sql that return types with arguments of type Expression | |
---|---|
List<Expression<?>> |
QBeans.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 |
|
SQLQueryImpl |
SQLQueryFactoryImpl.from(Expression<?> from)
|
|
Q |
SQLQueryFactory.from(Expression<?> from)
|
|
ResultSet |
AbstractSQLQuery.getResults(Expression<?>... exprs)
|
|
ResultSet |
SQLQuery.getResults(Expression<?>... args)
Get the results as an JDBC result set |
|
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 |
SQLQueryFactoryImpl.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<Expression<?>> args)
|
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.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 | |
---|---|
MySQLQuery |
MySQLQueryFactory.from(Expression<?> from)
|
SQLSubQuery |
MySQLQueryFactory.subQuery(Expression<?> from)
|
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 | ||
---|---|---|
OracleQuery |
OracleQueryFactory.from(Expression<?> from)
|
|
SumOver<A> |
SumOver.order(Expression<?>... orderBy)
|
|
OracleQuery |
OracleQuery.orderSiblingsBy(Expression<?> path)
|
|
SumOver<A> |
SumOver.partition(Expression<?> partitionBy)
|
|
SQLSubQuery |
OracleQueryFactory.subQuery(Expression<?> from)
|
|
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 |
---|
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(CollectionExpression<?,D> target,
Path<D> alias)
|
|
protected
|
QueryMixin.createAlias(Expression<D> path,
Path<D> alias)
|
|
protected
|
QueryMixin.createAlias(MapExpression<?,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 with parameters of type Expression | ||
---|---|---|
void |
OrderedQueryMetadata.addJoin(JoinType joinType,
Expression<?> expr)
|
|
T |
QueryMixin.addToProjection(Expression<?>... o)
|
|
protected void |
SerializerBase.appendAsString(Expression<?> expr)
|
|
static BooleanExpression |
Expressions.booleanTemplate(String template,
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)
|
|
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.numberTemplate(Class<T> cl,
String template,
Expression<?>... args)
|
|
static
|
Expressions.operation(Class<T> type,
Operator<? super T> operator,
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.stringTemplate(String template,
Expression<?>... args)
|
|
static
|
Expressions.template(Class<T> cl,
String template,
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<Expression<?>> args)
|
Constructors in com.mysema.query.support with parameters of type Expression | |
---|---|
SimpleQueryAdapter(Q query,
Expression<T> projection)
|
|
SimpleQueryAdapter(Query<?> 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 java.util.Collection typed expressions |
interface |
Constant<T>
Constant represents a general constant expression. |
interface |
EntityPath<T>
EntityPath is the common interface for entity path expressions |
interface |
FactoryExpression<T>
FactoryExpression represents factory expressions such as JavaBean or Constructor projections |
interface |
MapExpression<K,V>
MapExpression represents java.util.Map typed expressions |
interface |
Operation<T>
Operation represents an operation with operator and arguments |
interface |
ParametrizedExpression<T>
|
interface |
ParamExpression<T>
ParamExpression defines named and unnamed parameters in queries |
interface |
Path<T>
Path represents a path expression |
interface |
Predicate
Predicate is the common interface for Boolean typed expressions |
interface |
SubQueryExpression<T>
SubQueryExpression represents a sub query. |
interface |
TemplateExpression<T>
TemplateExpression provides base types for custom expressions with integrated serialization templates |
Classes in com.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 Expression implementations |
static class |
FactoryExpressionUtils.FactoryExpressionAdapter<T>
|
class |
MappingProjection<T>
Projection template that allows implementing arbitrary mapping of rows to result objects. |
class |
NullExpression<T>
NullExpression defines a general null expression |
class |
OperationImpl<T>
OperationImpl is the default implementation of the Operation interface |
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 | |
---|---|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toContainsViaLike
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toContainsViaLike
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toContainsViaLikeLower
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toContainsViaLikeLower
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toEndsWithViaLike
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toEndsWithViaLike
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toEndsWithViaLikeLower
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toEndsWithViaLikeLower
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toLowerCase
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toLowerCase
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toStartsWithViaLike
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toStartsWithViaLike
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toStartsWithViaLikeLower
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toStartsWithViaLikeLower
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toUpperCase
|
org.apache.commons.collections15.Transformer<Expression<String>,Expression<String>> |
Converters.toUpperCase
|
Methods in com.mysema.query.types that return Expression | ||
---|---|---|
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<?> |
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> |
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<?> |
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)
|
|
static PathMetadata<Integer> |
PathMetadataFactory.forListAccess(Path<?> parent,
Expression<Integer> index)
|
|
static
|
PathMetadataFactory.forMapAccess(Path<?> parent,
Expression<KT> key)
|
|
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
|
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)
|
Method parameters in com.mysema.query.types with type arguments of type Expression | |
---|---|
static Expression<?> |
ExpressionUtils.merge(List<? extends Expression<?>> expressions)
|
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)
|
|
QBean(Class<T> type,
Map<String,? extends Expression<?>> bindings)
|
|
QBean(Path<T> type,
boolean fieldAccess,
Map<String,? extends Expression<?>> bindings)
|
|
QBean(Path<T> type,
Map<String,? extends Expression<?>> bindings)
|
|
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 java.util.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 |
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
|
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)
|
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()
|
|
|
CaseBuilder.Initial.then(A constant)
|
|
|
CaseBuilder.Initial.then(Expression<A> expr)
|
|
|
CaseForEqBuilder.then(Expression<T> then)
|
|
|
CaseForEqBuilder.then(T then)
|
Methods in com.mysema.query.types.expr with parameters of type Expression | ||
---|---|---|
|
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 |
|
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 |
|
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
|
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
|
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)
|
|
|
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 EString to another EString , ignoring case
considerations. |
|
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 |
|
|
NumberExpression.loe(Expression<A> right)
Create a this <= right expression |
|
BooleanExpression |
ComparableExpression.loe(Expression<T> right)
Get a this < right expression |
|
|
NumberExpression.lt(Expression<A> right)
Create a this < right expression |
|
BooleanExpression |
ComparableExpression.lt(Expression<T> right)
Get a this < right expression |
|
BooleanExpression |
StringExpression.matches(Expression<String> regex)
Return true if this String matches the given regular expression |
|
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
|
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.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 |
|
Q |
CaseBuilder.Cases.otherwise(Expression<A> expr)
|
|
Q |
CaseForEqBuilder.Cases.otherwise(Expression<T> otherwise)
|
|
StringExpression |
StringExpression.prepend(Expression<String> str)
Prepend the given String and return the result |
|
BooleanExpression |
StringExpression.startsWith(Expression<String> str)
Return true if this starts with str |
|
BooleanExpression |
StringExpression.startsWithIgnoreCase(Expression<String> str)
|
|
|
NumberExpression.subtract(Expression<N> right)
Get the difference of this and right |
|
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 |
Constructors in com.mysema.query.types.expr with parameters of type Expression | |
---|---|
CaseForEqBuilder.CaseWhen(CaseForEqBuilder.Cases<T,Q> cases,
Expression<? extends D> when)
|
|
CaseForEqBuilder(Expression<D> base,
Expression<? extends D> other)
|
|
CaseForEqBuilder(Expression<D> base,
Expression<? extends D> other)
|
|
Coalesce(Class<? extends T> type,
Expression... exprs)
|
|
Coalesce(Expression... exprs)
|
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>
|
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 |
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 |
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<?> |
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<?>> |
SimpleTemplate.getArgs()
|
Methods in com.mysema.query.types.template with parameters of type Expression | ||
---|---|---|
static
|
SimpleTemplate.create(Class<? extends T> type,
String 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)
|
|
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 |