Package | Description |
---|---|
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.
|
Modifier and Type | Class and Description |
---|---|
class |
BooleanBuilder
BooleanBuilder is a cascading builder for
Predicate expressions. |
Modifier and Type | Method and Description |
---|---|
Expression<?> |
JoinFlag.getFlag() |
Expression<?> |
QueryFlag.getFlag() |
Expression<?> |
JoinExpression.getTarget() |
Modifier and Type | Method and Description |
---|---|
List<Expression<?>> |
EmptyMetadata.getGroupBy() |
List<Expression<?>> |
QueryMetadata.getGroupBy()
Get the group by expressions
|
List<Expression<?>> |
DefaultQueryMetadata.getGroupBy() |
List<Expression<?>> |
EmptyMetadata.getProjection() |
List<Expression<?>> |
QueryMetadata.getProjection()
Get the projection
|
List<Expression<?>> |
DefaultQueryMetadata.getProjection() |
Modifier and Type | Method and Description |
---|---|
void |
EmptyMetadata.addGroupBy(Expression<?> o) |
void |
QueryMetadata.addGroupBy(Expression<?> o)
Add the given group by expressions
|
void |
DefaultQueryMetadata.addGroupBy(Expression<?> o) |
void |
EmptyMetadata.addJoin(JoinType joinType,
Expression<?> expr) |
void |
QueryMetadata.addJoin(JoinType joinType,
Expression<?> expr)
Add the given query join
|
void |
DefaultQueryMetadata.addJoin(JoinType joinType,
Expression<?> expr) |
void |
EmptyMetadata.addProjection(Expression<?> o) |
void |
QueryMetadata.addProjection(Expression<?> o)
Add the given projections
|
void |
DefaultQueryMetadata.addProjection(Expression<?> o) |
<T> T |
Tuple.get(Expression<T> expr)
Get a tuple element by expression
|
Q |
Query.groupBy(Expression<?>... o)
Add grouping/aggregation expressions
|
com.mysema.commons.lang.CloseableIterator<Tuple> |
Projectable.iterate(Expression<?>... args)
iterate over the results for the given projection
|
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
Projectable.iterate(Expression<RT> projection)
iterate over the results for the given projection
|
ListSubQuery<Tuple> |
Detachable.list(Expression<?>... args)
Create a projection expression for the given projection
|
List<Tuple> |
Projectable.list(Expression<?>... args)
list the results for the given projection
An empty list is returned for no results.
|
<RT> ListSubQuery<RT> |
Detachable.list(Expression<RT> projection)
Create a projection expression for the given projection
|
<RT> List<RT> |
Projectable.list(Expression<RT> projection)
list the results for the given projection
An empty list is returned for no results.
|
SearchResults<Tuple> |
Projectable.listResults(Expression<?>... args)
list the results for the given projection
|
<RT> SearchResults<RT> |
Projectable.listResults(Expression<RT> projection)
list the results for the given projection
|
<K,V> Map<K,V> |
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.
|
<K,V> Map<K,V> |
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.
|
Tuple |
Projectable.singleResult(Expression<?>... args)
return a single result for the given projection or null if no result is found
|
<RT> RT |
Projectable.singleResult(Expression<RT> projection)
return a single result for the given projection or null if no result is found
|
SimpleSubQuery<Tuple> |
Detachable.unique(Expression<?>... args)
Create a projection expression for the given projection
|
<RT> SimpleSubQuery<RT> |
Detachable.unique(Expression<RT> projection)
Create a subquery expression for the given projection
|
Tuple |
Projectable.uniqueResult(Expression<?>... args)
return a unique result for the given projection or null if no result is found
|
<RT> RT |
Projectable.uniqueResult(Expression<RT> projection)
return a unique result for the given projection or null if no result is found
|
Constructor and Description |
---|
JoinExpression(JoinType type,
Expression<?> target)
Create a new JoinExpression instance
|
JoinExpression(JoinType type,
Expression<?> target,
Predicate condition,
Set<JoinFlag> flags)
Create a new JoinExpression instance
|
JoinFlag(Expression<?> flag) |
JoinFlag(Expression<?> flag,
JoinFlag.Position position) |
QueryFlag(QueryFlag.Position position,
Expression<?> flag) |
Modifier and Type | Method and Description |
---|---|
static <D extends Expression<?>> |
Alias.$()
Convert the given alias to an expression
|
<A extends Expression<?>> |
AliasFactory.getCurrent()
Get the current thread bound expression without reseting it
|
<A extends Expression<?>> |
AliasFactory.getCurrentAndReset()
Get the current thread bound expression and reset it
|
Modifier and Type | Method and Description |
---|---|
static <D> Expression<D> |
Alias.getAny(D arg)
Convert the given alias to an expression
|
Modifier and Type | Method and Description |
---|---|
static <A> A |
Alias.alias(Class<A> cl,
Expression<? extends A> expr)
Create a new alias proxy of the given type for the given expression
|
<A> A |
AliasFactory.createAliasForExpr(Class<A> cl,
Expression<? extends A> expr)
Create an alias instance for the given class and Expression
|
<A> A |
AliasFactory.createAliasForProperty(Class<A> cl,
Object parent,
Expression<?> path)
Create an alias instance for the given class, parent and path
|
protected <A> A |
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
|
Constructor and Description |
---|
PropertyAccessInvocationHandler(Expression<?> host,
AliasFactory aliasFactory,
PathFactory pathFactory,
TypeSystem typeSystem) |
Modifier and Type | Method and Description |
---|---|
<T> void |
DefaultConfiguration.addCustomType(Class<T> type,
Class<? extends Expression<T>> queryType) |
Modifier and Type | Method and Description |
---|---|
void |
TypeMappings.register(com.mysema.codegen.model.TypeCategory category,
Class<? extends Expression> expr,
Class<? extends Path> path,
Class<? extends TemplateExpression> template) |
Modifier and Type | Method and Description |
---|---|
static Number |
CollQueryFunctions.aggregate(Collection<Number> source,
Expression<?> expr,
Operator<?> aggregator) |
<T> com.mysema.codegen.Evaluator<T> |
DefaultEvaluatorFactory.create(QueryMetadata metadata,
List<? extends Expression<?>> sources,
Expression<T> projection)
Create an Evaluator for the given query sources and projection
|
<T> com.mysema.codegen.Evaluator<List<T>> |
DefaultEvaluatorFactory.createEvaluator(QueryMetadata metadata,
Expression<? extends T> source,
Predicate filter)
Create an Evaluator for the given source and filter
|
com.mysema.commons.lang.CloseableIterator<Tuple> |
AbstractCollQuery.iterate(Expression<?>... args) |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
AbstractCollQuery.iterate(Expression<RT> projection) |
List<Tuple> |
AbstractCollQuery.list(Expression<?>... args) |
<RT> List<RT> |
AbstractCollQuery.list(Expression<RT> projection) |
<T> List<T> |
QueryEngine.list(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables,
Expression<T> projection)
Evaluate the given query and return the projection as a list
|
<T> List<T> |
DefaultQueryEngine.list(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables,
Expression<T> projection) |
SearchResults<Tuple> |
AbstractCollQuery.listResults(Expression<?>... args) |
<RT> SearchResults<RT> |
AbstractCollQuery.listResults(Expression<RT> projection) |
<U> CollUpdateClause<T> |
CollUpdateClause.set(Path<U> path,
Expression<? extends U> expression) |
Tuple |
AbstractCollQuery.uniqueResult(Expression<?>... args) |
<RT> RT |
AbstractCollQuery.uniqueResult(Expression<RT> expr) |
static <F,T> com.google.common.base.Function<F,T> |
GuavaHelpers.wrap(Expression<T> projection)
Wrap a Querydsl expression into a Guava function
|
Modifier and Type | Method and Description |
---|---|
long |
QueryEngine.count(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables)
Evaluate the given query and return the count of matched rows
|
long |
DefaultQueryEngine.count(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables) |
<T> com.mysema.codegen.Evaluator<T> |
DefaultEvaluatorFactory.create(QueryMetadata metadata,
List<? extends Expression<?>> sources,
Expression<T> projection)
Create an Evaluator for the given query sources and projection
|
boolean |
QueryEngine.exists(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables) |
boolean |
DefaultQueryEngine.exists(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables) |
<T> List<T> |
QueryEngine.list(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables,
Expression<T> projection)
Evaluate the given query and return the projection as a list
|
<T> List<T> |
DefaultQueryEngine.list(QueryMetadata metadata,
Map<Expression<?>,Iterable<?>> iterables,
Expression<T> projection) |
protected void |
CollQuerySerializer.visitOperation(Class<?> type,
Operator<?> operator,
List<? extends Expression<?>> args) |
Modifier and Type | Method and Description |
---|---|
<T> C |
StoreClause.set(Path<T> path,
Expression<? extends T> expression)
Add an expression binding
|
Modifier and Type | Interface and Description |
---|---|
interface |
GroupExpression<T,R>
Defines the way results of a given expression are grouped.
|
Modifier and Type | Class and Description |
---|---|
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
|
Modifier and Type | Field and Description |
---|---|
protected Expression<?>[] |
GroupBy.expressions |
Modifier and Type | Method and Description |
---|---|
Expression<T> |
AbstractGroupExpression.getExpression() |
Expression<T> |
GroupExpression.getExpression() |
static <K,V> Expression<Map<K,V>> |
GroupBy.map(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression
|
Modifier and Type | Method and Description |
---|---|
ResultTransformer<Map<K,Group>> |
GroupByBuilder.as(Expression<?>... expressions) |
<V> ResultTransformer<Map<K,V>> |
GroupByBuilder.as(Expression<V> expression) |
static <E extends Number & Comparable<E>> |
GroupBy.avg(Expression<E> expression)
Create a new aggregating avg expression
|
static <K,V> QPair<K,V> |
QPair.create(Expression<K> key,
Expression<V> value) |
static <K,V> QPair<K,V> |
QPair.create(Expression<K> key,
Expression<V> value) |
boolean |
QPair.equals(Expression<?> keyExpr,
Class<?> valueType) |
boolean |
QPair.equals(Expression<?> keyExpr,
Expression<?> valueExpr) |
boolean |
QPair.equals(Expression<?> keyExpr,
Expression<?> valueExpr) |
<T> List<T> |
Group.getList(Expression<T> expr)
Returns a List of values in this group.
|
<K,V> Map<K,V> |
Group.getMap(Expression<K> key,
Expression<V> value)
Returns a Map of values in this group
|
<K,V> Map<K,V> |
Group.getMap(Expression<K> key,
Expression<V> value)
Returns a Map of values in this group
|
<T> T |
Group.getOne(Expression<T> expr)
Returns the value of the given single valued expression.
|
<T> Set<T> |
Group.getSet(Expression<T> expr)
Returns a Set of values in this group.
|
static GroupByBuilder<List<?>> |
GroupBy.groupBy(Expression<?>... keys)
Create a new GroupByBuilder for the given key expressions
|
static <K> GroupByBuilder<K> |
GroupBy.groupBy(Expression<K> key)
Create a new GroupByBuilder for the given key expression
|
static <E> AbstractGroupExpression<?,List<E>> |
GroupBy.list(Expression<E> expression)
Create a new aggregating list expression
|
static <K,V> Expression<Map<K,V>> |
GroupBy.map(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression
|
static <K,V> Expression<Map<K,V>> |
GroupBy.map(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression
|
static <E extends Comparable<E>> |
GroupBy.max(Expression<E> expression)
Create a new aggregating max expression
|
static <E extends Comparable<E>> |
GroupBy.min(Expression<E> expression)
Create a new aggregating min expression
|
static <E> AbstractGroupExpression<?,Set<E>> |
GroupBy.set(Expression<E> expression)
Create a new aggregating set expression
|
static <E extends Number & Comparable<E>> |
GroupBy.sum(Expression<E> expression)
Create a new aggregating sum expression
|
Constructor and Description |
---|
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) |
Modifier and Type | Method and Description |
---|---|
Expression<?> |
JDOQLSerializer.getCandidatePath() |
Modifier and Type | Method and Description |
---|---|
com.mysema.commons.lang.CloseableIterator<Tuple> |
AbstractJDOQuery.iterate(Expression<?>... args) |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
AbstractJDOQuery.iterate(Expression<RT> projection) |
List<Tuple> |
AbstractJDOQuery.list(Expression<?>... args) |
<RT> List<RT> |
AbstractJDOQuery.list(Expression<RT> expr) |
SearchResults<Tuple> |
AbstractJDOQuery.listResults(Expression<?>... args) |
<RT> SearchResults<RT> |
AbstractJDOQuery.listResults(Expression<RT> expr) |
Tuple |
AbstractJDOQuery.uniqueResult(Expression<?>... args) |
<RT> RT |
AbstractJDOQuery.uniqueResult(Expression<RT> expr) |
Modifier and Type | Method and Description |
---|---|
protected void |
JDOQLSerializer.visitOperation(Class<?> type,
Operator<?> operator,
List<? extends Expression<?>> args) |
Constructor and Description |
---|
JDOQLSerializer(JDOQLTemplates templates,
Expression<?> candidate) |
Modifier and Type | Method and Description |
---|---|
<T> JDOUpdateClause |
JDOUpdateClause.set(Path<T> path,
Expression<? extends T> expression) |
Modifier and Type | Field and Description |
---|---|
protected Expression<?> |
AbstractSQLQuery.union |
Modifier and Type | Method and Description |
---|---|
T |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
Expression<?> flag) |
T |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
String prefix,
Expression<?> expr) |
T |
AbstractSQLQuery.from(Expression<?>... args) |
T |
AbstractSQLQuery.from(Expression<?> arg) |
com.mysema.commons.lang.CloseableIterator<Tuple> |
JDOSQLQuery.iterate(Expression<?>... args) |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
JDOSQLQuery.iterate(Expression<RT> projection) |
List<Tuple> |
JDOSQLQuery.list(Expression<?>... args) |
<RT> List<RT> |
JDOSQLQuery.list(Expression<RT> expr) |
SearchResults<Tuple> |
JDOSQLQuery.listResults(Expression<?>... args) |
<RT> SearchResults<RT> |
JDOSQLQuery.listResults(Expression<RT> expr) |
Tuple |
JDOSQLQuery.uniqueResult(Expression<?>... args) |
<RT> RT |
JDOSQLQuery.uniqueResult(Expression<RT> expr) |
Modifier and Type | Field and Description |
---|---|
protected Expression<?> |
AbstractSQLQuery.union |
Modifier and Type | Method and Description |
---|---|
static <RT> Expression<RT> |
Conversions.convert(Expression<RT> expr) |
<RT> Expression<RT> |
JPAQueryMixin.convert(Expression<RT> expr) |
static <RT> Expression<RT> |
Conversions.convertForNativeQuery(Expression<RT> expr) |
Modifier and Type | Method and Description |
---|---|
T |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
Expression<?> flag) |
T |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
String prefix,
Expression<?> expr) |
static <RT> Expression<RT> |
Conversions.convert(Expression<RT> expr) |
<RT> Expression<RT> |
JPAQueryMixin.convert(Expression<RT> expr) |
static <RT> Expression<RT> |
Conversions.convertForNativeQuery(Expression<RT> expr) |
T |
AbstractSQLQuery.from(Expression<?>... args) |
T |
AbstractSQLQuery.from(Expression<?> arg) |
Modifier and Type | Method and Description |
---|---|
protected void |
JPQLSerializer.visitOperation(Class<?> type,
Operator<?> operator,
List<? extends Expression<?>> args) |
Modifier and Type | Method and Description |
---|---|
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<Tuple> |
AbstractHibernateQuery.iterate(Expression<?>... args)
Return the query results as an Iterator.
Entities returned as results are initialized on demand. |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
AbstractHibernateQuery.iterate(Expression<RT> projection)
Return the query results as an Iterator.
|
List<Tuple> |
AbstractHibernateQuery.list(Expression<?>... args) |
<RT> List<RT> |
AbstractHibernateQuery.list(Expression<RT> expr) |
SearchResults<Tuple> |
AbstractHibernateQuery.listResults(Expression<?>... args) |
<RT> SearchResults<RT> |
AbstractHibernateQuery.listResults(Expression<RT> expr) |
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<?> expr)
Return the query results as ScrollableResults.
|
<T> HibernateUpdateClause |
HibernateUpdateClause.set(Path<T> path,
Expression<? extends T> expression) |
Tuple |
AbstractHibernateQuery.uniqueResult(Expression<?>... args) |
<RT> RT |
AbstractHibernateQuery.uniqueResult(Expression<RT> expr) |
Modifier and Type | Method and Description |
---|---|
org.hibernate.Query |
AbstractHibernateSQLQuery.createQuery(Expression<?>... args) |
com.mysema.commons.lang.CloseableIterator<Tuple> |
AbstractHibernateSQLQuery.iterate(Expression<?>... args) |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
AbstractHibernateSQLQuery.iterate(Expression<RT> projection) |
List<Tuple> |
AbstractHibernateSQLQuery.list(Expression<?>... projection) |
<RT> List<RT> |
AbstractHibernateSQLQuery.list(Expression<RT> projection) |
SearchResults<Tuple> |
AbstractHibernateSQLQuery.listResults(Expression<?>... args) |
<RT> SearchResults<RT> |
AbstractHibernateSQLQuery.listResults(Expression<RT> projection) |
Tuple |
AbstractHibernateSQLQuery.uniqueResult(Expression<?>... args) |
<RT> RT |
AbstractHibernateSQLQuery.uniqueResult(Expression<RT> expr) |
Modifier and Type | Method and Description |
---|---|
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<Tuple> |
AbstractJPAQuery.iterate(Expression<?>... args) |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
AbstractJPAQuery.iterate(Expression<RT> expr) |
List<Tuple> |
AbstractJPAQuery.list(Expression<?>... args) |
<RT> List<RT> |
AbstractJPAQuery.list(Expression<RT> expr) |
SearchResults<Tuple> |
AbstractJPAQuery.listResults(Expression<?>... args) |
<RT> SearchResults<RT> |
AbstractJPAQuery.listResults(Expression<RT> expr) |
<T> JPAUpdateClause |
JPAUpdateClause.set(Path<T> path,
Expression<? extends T> expression) |
Tuple |
AbstractJPAQuery.uniqueResult(Expression<?>... args) |
<RT> RT |
AbstractJPAQuery.uniqueResult(Expression<RT> expr) |
Modifier and Type | Method and Description |
---|---|
javax.persistence.Query |
AbstractJPASQLQuery.createQuery(Expression<?>... args) |
com.mysema.commons.lang.CloseableIterator<Tuple> |
AbstractJPASQLQuery.iterate(Expression<?>... args) |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
AbstractJPASQLQuery.iterate(Expression<RT> expr) |
List<Tuple> |
AbstractJPASQLQuery.list(Expression<?>... args) |
<RT> List<RT> |
AbstractJPASQLQuery.list(Expression<RT> projection) |
SearchResults<Tuple> |
AbstractJPASQLQuery.listResults(Expression<?>... args) |
<RT> SearchResults<RT> |
AbstractJPASQLQuery.listResults(Expression<RT> projection) |
Tuple |
AbstractJPASQLQuery.uniqueResult(Expression<?>... args) |
<RT> RT |
AbstractJPASQLQuery.uniqueResult(Expression<RT> expr) |
Modifier and Type | Class and Description |
---|---|
class |
PhraseElement
PhraseElement represents the embedded String as a phrase
|
class |
QueryElement
QueryElement wraps a Lucene Query
|
class |
TermElement
TermElement represents the embedded String as a term
|
Modifier and Type | Method and Description |
---|---|
protected String[] |
LuceneSerializer.convert(Path<?> leftHandSide,
Expression<?> rightHandSide,
QueryMetadata metadata)
template method
|
protected org.apache.lucene.search.Query |
LuceneSerializer.range(Path<?> leftHandSide,
String field,
Expression<?> min,
Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.range(Path<?> leftHandSide,
String field,
Expression<?> min,
Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.stringRange(Path<?> leftHandSide,
String field,
Expression<?> min,
Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.stringRange(Path<?> leftHandSide,
String field,
Expression<?> min,
Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
org.apache.lucene.search.Query |
LuceneSerializer.toQuery(Expression<?> expr,
QueryMetadata metadata) |
Modifier and Type | Class and Description |
---|---|
class |
Point
Point is an adapter type for Double[] arrays to use geo spatial querying features of Mongodb
|
Modifier and Type | Method and Description |
---|---|
Object |
MongodbSerializer.handle(Expression<?> expression) |
static BooleanExpression |
MongodbExpressions.near(Expression<Double[]> expr,
double latVal,
double longVal)
Finds the closest points relative to the given location and orders the results with decreasing promimity
|
Modifier and Type | Method and Description |
---|---|
protected com.mongodb.DBCursor |
MongodbQuery.createCursor(com.mongodb.DBCollection collection,
Predicate where,
List<Expression<?>> projection,
QueryModifiers modifiers,
List<OrderSpecifier<?>> orderBy) |
Modifier and Type | Interface and Description |
---|---|
interface |
RelationalPath<T>
RelationalPath extends
EntityPath to provide access to relational metadata |
Modifier and Type | Class and Description |
---|---|
class |
QBeans
Expression used to project a list of beans
|
class |
RelationalFunctionCall<T>
Represents a table valued function call
|
class |
RelationalPathBase<T>
RelationalPathBase is a base class for
RelationalPath implementations |
class |
WindowFunction<A> |
class |
WindowOver<T>
WindowOver is the first part of a WindowFunction construction
|
Modifier and Type | Field and Description |
---|---|
static Expression<Object[]> |
SQLExpressions.all
Wildcard expression
|
static Expression<Long> |
SQLExpressions.countAll
Wilcard count expression
|
static Expression<?> |
SQLTemplates.RECURSIVE |
protected Expression<?> |
AbstractSQLQuery.union |
Modifier and Type | Method and Description |
---|---|
Expression<Tuple> |
ForeignKey.getProjection() |
Expression<Tuple> |
PrimaryKey.getProjection() |
static Expression<?> |
UnionUtils.union(SubQueryExpression<?>[] union,
boolean unionAll) |
static Expression<?> |
UnionUtils.union(SubQueryExpression<?>[] union,
Path<?> alias,
boolean unionAll) |
Modifier and Type | Method and Description |
---|---|
List<Expression<?>> |
QBeans.getArgs() |
Modifier and Type | Method and Description |
---|---|
Q |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
Expression<?> flag)
Add the given Expression as a query flag
|
Q |
AbstractSQLSubQuery.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 |
AbstractSQLQuery.addFlag(QueryFlag.Position position,
String prefix,
Expression<?> expr)
Add the given prefix and expression as a general query flag
|
Q |
AbstractSQLSubQuery.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
|
R |
WithBuilder.as(Expression<?> expr) |
SimpleExpression<A> |
WindowFunction.as(Expression<A> alias) |
static <T extends Number> |
SQLExpressions.avg(Expression<T> expr) |
static WindowOver<Long> |
SQLExpressions.count(Expression<?> expr) |
static Set<RelationalPath<?>> |
RelationalPathExtractor.extract(Expression<?> expr) |
static <T> WindowOver<T> |
SQLExpressions.firstValue(Expression<T> expr)
returns value evaluated at the row that is the first row of the window frame
|
Q |
AbstractSQLQuery.from(Expression<?>... args) |
Q |
AbstractSQLSubQuery.from(Expression<?>... args) |
Q |
AbstractSQLQueryFactory.from(Expression<?>... args) |
Q |
SQLCommonQuery.from(Expression<?>... o)
Defines the sources of the query
|
Q |
SQLQueryFactory.from(Expression<?>... from)
Create a new SELECT query
|
Q |
AbstractSQLQuery.from(Expression<?> arg) |
Q |
AbstractSQLSubQuery.from(Expression<?> arg) |
Q |
AbstractSQLQueryFactory.from(Expression<?> from) |
Q |
SQLQueryFactory.from(Expression<?> from)
Create a new SELECT query
|
ResultSet |
AbstractSQLQuery.getResults(Expression<?>... exprs)
Get the results as an JDBC result set
|
SQLBindings |
AbstractSQLQuery.getSQL(Expression<?>... exprs)
Get the query as an SQL query string and bindings
|
Union<RT> |
Union.groupBy(Expression<?>... o)
Defines the grouping/aggregation expressions
|
Union<RT> |
UnionImpl.groupBy(Expression<?>... o) |
com.mysema.commons.lang.CloseableIterator<Tuple> |
AbstractSQLQuery.iterate(Expression<?>... args) |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
AbstractSQLQuery.iterate(Expression<RT> expr) |
static <T> WindowOver<T> |
SQLExpressions.lag(Expression<T> expr)
expr evaluated at the row that is one row before the current row within the partition
|
static <T> WindowOver<T> |
SQLExpressions.lastValue(Expression<T> expr)
returns value evaluated at the row that is the last row of the window frame
|
static <T> WindowOver<T> |
SQLExpressions.lead(Expression<T> expr)
expr evaluated at the row that is one row after the current row within the partition;
|
static StringExpression |
SQLExpressions.left(Expression<String> lhs,
Expression<Integer> rhs) |
static StringExpression |
SQLExpressions.left(Expression<String> lhs,
Expression<Integer> rhs) |
static StringExpression |
SQLExpressions.left(Expression<String> lhs,
int rhs) |
List<Tuple> |
AbstractSQLQuery.list(Expression<?>... args) |
<RT> List<RT> |
AbstractSQLQuery.list(Expression<RT> expr) |
SearchResults<Tuple> |
AbstractSQLQuery.listResults(Expression<?>... args) |
<RT> SearchResults<RT> |
AbstractSQLQuery.listResults(Expression<RT> expr) |
static <T extends Comparable> |
SQLExpressions.max(Expression<T> expr) |
static <T extends Comparable> |
SQLExpressions.min(Expression<T> expr) |
WindowFunction<A> |
WindowFunction.partitionBy(Expression<?>... partitionBy) |
WindowFunction<A> |
WindowFunction.partitionBy(Expression<?> partitionBy) |
static StringExpression |
SQLExpressions.right(Expression<String> lhs,
Expression<Integer> rhs) |
static StringExpression |
SQLExpressions.right(Expression<String> lhs,
Expression<Integer> rhs) |
static StringExpression |
SQLExpressions.right(Expression<String> lhs,
int rhs) |
void |
SQLSerializer.serializeUnion(Expression<?> union,
QueryMetadata metadata,
boolean unionAll) |
SQLSubQuery |
AbstractSQLQueryFactory.subQuery(Expression<?> from) |
SQ |
SQLQueryFactory.subQuery(Expression<?> from) |
static <T extends Number> |
SQLExpressions.sum(Expression<T> expr) |
Tuple |
AbstractSQLQuery.uniqueResult(Expression<?>... expr) |
<RT> RT |
AbstractSQLQuery.uniqueResult(Expression<RT> expr) |
Q |
AbstractSQLQuery.with(Path<?> alias,
Expression<?> query) |
Q |
AbstractSQLQuery.withRecursive(Path<?> alias,
Expression<?> query) |
Modifier and Type | Method and Description |
---|---|
void |
SQLListener.notifyInsert(QueryMetadata md,
RelationalPath<?> entity,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLListeners.notifyInsert(QueryMetadata md,
RelationalPath<?> entity,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLListener.notifyMerge(QueryMetadata md,
RelationalPath<?> entity,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLListeners.notifyMerge(QueryMetadata md,
RelationalPath<?> entity,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLListener.notifyUpdate(QueryMetadata md,
RelationalPath<?> entity,
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates) |
void |
SQLListeners.notifyUpdate(QueryMetadata md,
RelationalPath<?> entity,
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates) |
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 and Description |
---|
WindowFunction(Expression<A> expr) |
WindowOver(Class<T> type,
Operator<? super T> op,
Expression<?> arg) |
WithBuilder(QueryMixin<R> queryMixin,
Expression<?> alias) |
Constructor and Description |
---|
UnionImpl(Q query,
List<? extends Expression<?>> projection) |
Modifier and Type | Method and Description |
---|---|
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> |
SQLUpdateBatch.getUpdates() |
List<Expression<?>> |
SQLInsertBatch.getValues() |
List<Expression<?>> |
SQLMergeBatch.getValues() |
Modifier and Type | Method and Description |
---|---|
SQLDeleteClause |
SQLDeleteClause.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
|
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
|
<T> SQLUpdateClause |
SQLUpdateClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> SQLMergeClause |
SQLMergeClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> SQLInsertClause |
SQLInsertClause.set(Path<T> path,
Expression<? extends T> expression) |
Constructor and Description |
---|
SQLInsertBatch(List<Path<?>> c,
List<Expression<?>> v,
SubQueryExpression<?> sq) |
SQLMergeBatch(List<Path<?>> k,
List<Path<?>> c,
List<Expression<?>> v,
SubQueryExpression<?> sq) |
SQLUpdateBatch(QueryMetadata metadata,
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates) |
Modifier and Type | Class and Description |
---|---|
class |
RowNumber
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
RowNumber |
RowNumber.as(Expression<Long> target)
Deprecated.
|
RowNumber |
RowNumber.partitionBy(Expression<?>... exprs)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
SQLInsertClause |
MySQLQueryFactory.insertOnDuplicateKeyUpdate(RelationalPath<?> entity,
Expression<?> clause) |
Modifier and Type | Class and Description |
---|---|
class |
SumOver<A extends Number & Comparable<? super A>>
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
SumOver<A> |
SumOver.orderBy(Expression<?>... orderBy)
Deprecated.
|
OracleQuery |
OracleQuery.orderSiblingsBy(Expression<?> path) |
SumOver<A> |
SumOver.partition(Expression<?> partitionBy)
Deprecated.
|
static <A extends Number & Comparable<? super A>> |
OracleGrammar.sumOver(Expression<A> expr)
Deprecated.
|
Constructor and Description |
---|
SumOver(Expression<A> expr)
Deprecated.
|
Modifier and Type | Class and Description |
---|---|
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
|
Modifier and Type | Method and Description |
---|---|
<E> Expression<E> |
QueryMixin.addProjection(Expression<E> e) |
static <T> Expression<T> |
Expressions.constant(T value)
Create a Constant expression for the given value
|
<RT> Expression<RT> |
QueryMixin.convert(Expression<RT> expr) |
protected <D> Expression<D> |
QueryMixin.createAlias(Expression expr,
Path alias) |
Expression<?> |
ListAccessVisitor.visit(Constant<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(Constant<?> expr,
Context context) |
Expression<?> |
ListAccessVisitor.visit(FactoryExpression<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(FactoryExpression<?> expr,
Context context) |
Expression<?> |
ListAccessVisitor.visit(Operation<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(Operation<?> expr,
Context context) |
Expression<?> |
ListAccessVisitor.visit(ParamExpression<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(ParamExpression<?> expr,
Context context) |
Expression<?> |
ListAccessVisitor.visit(Path<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(Path<?> expr,
Context context) |
Expression<?> |
ListAccessVisitor.visit(SubQueryExpression<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(SubQueryExpression<?> expr,
Context context) |
Expression<?> |
ListAccessVisitor.visit(TemplateExpression<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(TemplateExpression<?> expr,
Context context) |
Modifier and Type | Method and Description |
---|---|
List<Expression<?>> |
NumberConversion.getArgs() |
List<Expression<?>> |
NumberConversions.getArgs() |
Modifier and Type | Method and Description |
---|---|
void |
OrderedQueryMetadata.addJoin(JoinType joinType,
Expression<?> expr) |
T |
QueryMixin.addJoin(JoinType joinType,
Expression<?> target) |
T |
QueryMixin.addProjection(Expression<?>... o) |
<E> Expression<E> |
QueryMixin.addProjection(Expression<E> e) |
static <D> SimpleExpression<D> |
Expressions.as(Expression<D> source,
Path<D> alias) |
static <D> SimpleExpression<D> |
Expressions.as(Expression<D> source,
String alias)
Create the alias expression source as alias
|
static BooleanExpression |
Expressions.booleanOperation(Operator<Boolean> operation,
Expression<?>... args)
Create a new Boolean operation
|
static <T extends Comparable<?>> |
Expressions.comparableOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
Create a new Operation expression
|
<RT> Expression<RT> |
QueryMixin.convert(Expression<RT> expr) |
protected <D> Expression<D> |
QueryMixin.createAlias(Expression expr,
Path alias) |
static <T extends Comparable<?>> |
Expressions.dateOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
Create a new Operation expression
|
static <T extends Comparable<?>> |
Expressions.dateTimeOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
Create a new Operation expression
|
static <T> DslExpression<T> |
Expressions.dslOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
Create a new Operation expression
|
T |
QueryMixin.from(Expression<?>... args) |
T |
QueryMixin.from(Expression<?> arg) |
T |
QueryMixin.fullJoin(Expression<?> target) |
<P> T |
QueryMixin.fullJoin(Expression<P> target,
Path<P> alias) |
T |
QueryMixin.groupBy(Expression<?>... o) |
Q |
QueryBase.groupBy(Expression<?>... o)
Add grouping/aggregation expressions
|
T |
QueryMixin.groupBy(Expression<?> e) |
Q |
QueryBase.groupBy(Expression<?> e)
Add a single grouping expression
|
S |
SerializerBase.handle(Expression<?> expr) |
S |
SerializerBase.handle(String sep,
Expression<?>[] expressions) |
<P> T |
QueryMixin.innerJoin(Expression<P> target) |
<P> T |
QueryMixin.innerJoin(Expression<P> target,
Path<P> alias) |
com.mysema.commons.lang.CloseableIterator<Tuple> |
ProjectableAdapter.iterate(Expression<?>... args) |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
ProjectableAdapter.iterate(Expression<RT> projection) |
<P> T |
QueryMixin.join(Expression<P> target) |
<P> T |
QueryMixin.join(Expression<P> target,
Path<P> alias) |
<P> T |
QueryMixin.leftJoin(Expression<P> target) |
<P> T |
QueryMixin.leftJoin(Expression<P> target,
Path<P> alias) |
List<Tuple> |
ProjectableQuery.list(Expression<?>... args) |
ListSubQuery<Tuple> |
DetachableMixin.list(Expression<?>... args) |
ListSubQuery<Tuple> |
DetachableQuery.list(Expression<?>... args) |
ListSubQuery<Tuple> |
DetachableAdapter.list(Expression<?>... args) |
List<Tuple> |
ProjectableAdapter.list(Expression<?>[] args) |
ListSubQuery<Tuple> |
DetachableAdapter.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest) |
ListSubQuery<Tuple> |
DetachableAdapter.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest) |
ListSubQuery<Tuple> |
DetachableAdapter.list(Expression<?> first,
Expression<?> second,
Expression<?>... rest) |
<RT> List<RT> |
ProjectableQuery.list(Expression<RT> projection) |
<RT> ListSubQuery<RT> |
DetachableMixin.list(Expression<RT> projection) |
<RT> ListSubQuery<RT> |
DetachableQuery.list(Expression<RT> projection) |
<RT> ListSubQuery<RT> |
DetachableAdapter.list(Expression<RT> projection) |
<RT> List<RT> |
ProjectableAdapter.list(Expression<RT> projection) |
SearchResults<Tuple> |
ProjectableAdapter.listResults(Expression<?>... args) |
<RT> SearchResults<RT> |
ProjectableAdapter.listResults(Expression<RT> expr) |
<K,V> Map<K,V> |
ProjectableQuery.map(Expression<K> key,
Expression<V> value) |
<K,V> Map<K,V> |
ProjectableQuery.map(Expression<K> key,
Expression<V> value) |
<K,V> Map<K,V> |
ProjectableAdapter.map(Expression<K> key,
Expression<V> value) |
<K,V> Map<K,V> |
ProjectableAdapter.map(Expression<K> key,
Expression<V> value) |
static <T extends Number & Comparable<?>> |
Expressions.numberOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
Create a new Operation expression
|
static <T> SimpleExpression<T> |
Expressions.operation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
Create a new Operation expression
|
static BooleanExpression |
Expressions.predicate(Operator<Boolean> operation,
Expression<?>... args)
Create a new Predicate operation
|
<P> T |
QueryMixin.rightJoin(Expression<P> target) |
<P> T |
QueryMixin.rightJoin(Expression<P> target,
Path<P> alias) |
Tuple |
ProjectableQuery.singleResult(Expression<?>... args) |
Tuple |
ProjectableAdapter.singleResult(Expression<?>... args) |
<RT> RT |
ProjectableQuery.singleResult(Expression<RT> expr) |
<RT> RT |
ProjectableAdapter.singleResult(Expression<RT> expr) |
static StringExpression |
Expressions.stringOperation(Operator<? super String> operator,
Expression<?>... args)
Create a new Operation expression
|
static <T extends Comparable<?>> |
Expressions.timeOperation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
Create a new Operation expression
|
SimpleSubQuery<Tuple> |
DetachableMixin.unique(Expression<?>... args) |
SimpleSubQuery<Tuple> |
DetachableQuery.unique(Expression<?>... args) |
SimpleSubQuery<Tuple> |
DetachableAdapter.unique(Expression<?>... args) |
SimpleSubQuery<Tuple> |
DetachableAdapter.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest) |
SimpleSubQuery<Tuple> |
DetachableAdapter.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest) |
SimpleSubQuery<Tuple> |
DetachableAdapter.unique(Expression<?> first,
Expression<?> second,
Expression<?>... rest) |
<RT> SimpleSubQuery<RT> |
DetachableMixin.unique(Expression<RT> projection) |
<RT> SimpleSubQuery<RT> |
DetachableQuery.unique(Expression<RT> projection) |
<RT> SimpleSubQuery<RT> |
DetachableAdapter.unique(Expression<RT> projection) |
Tuple |
ProjectableAdapter.uniqueResult(Expression<?>... args) |
<RT> RT |
ProjectableAdapter.uniqueResult(Expression<RT> expr) |
Modifier and Type | Method and Description |
---|---|
protected void |
SerializerBase.visitOperation(Class<?> type,
Operator<?> operator,
List<? extends Expression<?>> args) |
Constructor and Description |
---|
NumberConversion(Expression<T> expr) |
SimpleProjectableAdapter(Q query,
Expression<T> projection) |
SimpleProjectableAdapter(SimpleQuery<?> query,
Projectable projectable,
Expression<T> projection) |
Modifier and Type | Interface and Description |
---|---|
interface |
CollectionExpression<T extends Collection<E>,E>
CollectionExpression represents
Collection typed expressions |
interface |
Constant<T>
Constant represents a general constant expression.
|
interface |
EntityPath<T>
EntityPath is the common interface for entity path expressions
|
interface |
FactoryExpression<T>
FactoryExpression represents factory expressions such as JavaBean or
Constructor projections
|
interface |
MapExpression<K,V>
MapExpression represents
Map typed expressions |
interface |
Operation<T>
Operation represents an operation with operator and arguments
|
interface |
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 |
SubQueryExpression<T>
SubQueryExpression represents a sub query.
|
interface |
TemplateExpression<T>
TemplateExpression provides base types for custom expressions with integrated
serialization templates
|
Modifier and Type | Class and Description |
---|---|
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 |
QList
QList represents a projection of type List
|
class |
QMap
QMap represents a projection of type Map
|
class |
QTuple
QTuple represents a projection of type Tuple
|
class |
SubQueryExpressionImpl<T>
SubQueryExpressionImpl is the default implementation of the
SubQueryExpression interface |
class |
TemplateExpressionImpl<T>
Default implementation of the
TemplateExpression interface |
Modifier and Type | Method and Description |
---|---|
static <T> Expression<T> |
ExpressionUtils.all(CollectionExpression<?,? super T> col) |
static <T> Expression<T> |
ExpressionUtils.any(CollectionExpression<?,? super T> col) |
static <D> Expression<D> |
ExpressionUtils.as(Expression<D> source,
Path<D> alias)
Create an alias expression (source as alias) with the given source and alias
|
static <D> Expression<D> |
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
|
static Expression<Long> |
ExpressionUtils.count(Expression<?> source) |
static <C> Expression<C> |
TemplateExpressionImpl.create(Class<C> cl,
String template) |
static <C> Expression<C> |
TemplateExpressionImpl.create(Class<C> cl,
String template,
Object... args) |
static <C> Expression<C> |
TemplateExpressionImpl.create(Class<C> cl,
String template,
Object one) |
static <C> Expression<C> |
TemplateExpressionImpl.create(Class<C> cl,
String template,
Object one,
Object two) |
static <C> Expression<C> |
TemplateExpressionImpl.create(Class<C> cl,
Template template,
Object... args) |
static <T> Expression<T> |
ExpressionUtils.extract(Expression<T> expr) |
Expression<?> |
Operation.getArg(int index)
Get the argument with the given index
|
Expression<?> |
OperationImpl.getArg(int i) |
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 <T> Expression<T> |
ExpressionUtils.list(Class<T> clazz,
Expression<?>... exprs) |
static <T> Expression<T> |
ExpressionUtils.list(Class<T> clazz,
List<? extends Expression<?>> exprs) |
static Expression<String> |
ExpressionUtils.regexToLike(Expression<String> expr) |
Modifier and Type | Method and Description |
---|---|
static com.google.common.collect.ImmutableList<Expression<?>> |
ExpressionUtils.distinctList(Expression<?>... args) |
static com.google.common.collect.ImmutableList<Expression<?>> |
ExpressionUtils.distinctList(Expression<?>[]... args) |
List<Expression<?>> |
FactoryExpressionUtils.FactoryExpressionAdapter.getArgs() |
List<Expression<?>> |
Operation.getArgs()
Get the arguments of this operation
|
List<Expression<?>> |
ConstructorExpression.getArgs() |
List<Expression<?>> |
FactoryExpression.getArgs()
Get the invocation arguments
|
List<Expression<?>> |
QList.getArgs() |
List<Expression<?>> |
MappingProjection.getArgs() |
List<Expression<?>> |
ArrayConstructorExpression.getArgs() |
List<Expression<?>> |
QMap.getArgs() |
List<Expression<?>> |
QBean.getArgs() |
List<Expression<?>> |
QTuple.getArgs() |
List<Expression<?>> |
OperationImpl.getArgs() |
Map<Expression<?>,?> |
QMap.newInstance(Object... args) |
Set<Expression<?>> |
ValidatingVisitor.visit(Constant<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(FactoryExpression<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(Operation<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(ParamExpression<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(Path<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(SubQueryExpression<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(TemplateExpression<?> expr,
Set<Expression<?>> known) |
Modifier and Type | Method and Description |
---|---|
static <T> ArrayConstructorExpression<T> |
Projections.array(Class<T[]> type,
Expression<T>... exprs)
Create a typed array projection for the given type and expressions
|
static <D> Expression<D> |
ExpressionUtils.as(Expression<D> source,
Path<D> alias)
Create an alias expression (source as alias) with the given source and alias
|
static <D> Expression<D> |
ExpressionUtils.as(Expression<D> source,
String alias)
Create an alias expression (source as alias) with the given source and alias
|
static <T> QBean<T> |
Projections.bean(Class<T> type,
Expression<?>... exprs)
Create a Bean populating projection for the given type and expressions
|
static <T> QBean<T> |
Projections.bean(Path<T> type,
Expression<?>... exprs)
Create a Bean populating projection for the given type and expressions
|
static <T> ConstructorExpression<T> |
Projections.constructor(Class<T> type,
Expression<?>... exprs)
Create a constructor invocation projection for the given type and expressions
|
static Expression<Long> |
ExpressionUtils.count(Expression<?> source) |
static <RT> Operation<RT> |
OperationImpl.create(Class<? extends RT> type,
Operator<? super RT> operator,
Expression<?> one) |
static <RT> Operation<RT> |
OperationImpl.create(Class<? extends RT> type,
Operator<? super RT> operator,
Expression<?> one,
Expression<?> two) |
static <RT> Operation<RT> |
OperationImpl.create(Class<? extends RT> type,
Operator<? super RT> operator,
Expression<?> one,
Expression<?> two) |
static <D> ConstructorExpression<D> |
ConstructorExpression.create(Class<D> type,
Expression<?>... args) |
static PredicateOperation |
PredicateOperation.create(Operator<Boolean> operator,
Expression<?> one) |
static PredicateOperation |
PredicateOperation.create(Operator<Boolean> operator,
Expression<?> one,
Expression<?> two) |
static PredicateOperation |
PredicateOperation.create(Operator<Boolean> operator,
Expression<?> one,
Expression<?> two) |
static com.google.common.collect.ImmutableList<Expression<?>> |
ExpressionUtils.distinctList(Expression<?>... args) |
static com.google.common.collect.ImmutableList<Expression<?>> |
ExpressionUtils.distinctList(Expression<?>[]... args) |
static <D> Predicate |
ExpressionUtils.eq(Expression<D> left,
Expression<? extends D> right)
Create an left equals right expression
|
static <D> Predicate |
ExpressionUtils.eq(Expression<D> left,
Expression<? extends D> right)
Create an left equals right expression
|
static <D> Predicate |
ExpressionUtils.eqConst(Expression<D> left,
D constant)
Create an left equals constant expression
|
static <T> Expression<T> |
ExpressionUtils.extract(Expression<T> expr) |
static <T> QBean<T> |
Projections.fields(Class<T> type,
Expression<?>... exprs)
Create a field access based Bean populating projection for the given type and expressions
|
static <T> QBean<T> |
Projections.fields(Path<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 <KT> PathMetadata<KT> |
PathMetadataFactory.forMapAccess(Path<?> parent,
Expression<KT> key)
Create a new PathMetadata for key based map access
|
static <D> Predicate |
ExpressionUtils.in(Expression<D> left,
Collection<? extends D> right)
Create an left in right expression
|
static <D> Predicate |
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 <T> Expression<T> |
ExpressionUtils.list(Class<T> clazz,
Expression<?>... exprs) |
static QMap |
Projections.map(Expression<?>... exprs)
Create a Map typed projection for the given expressions
|
static <D> Predicate |
ExpressionUtils.ne(Expression<D> left,
Expression<? super D> right)
Create a left not equals right expression
|
static <D> Predicate |
ExpressionUtils.ne(Expression<D> left,
Expression<? super D> right)
Create a left not equals right expression
|
static <D> Predicate |
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
|
Modifier and Type | Method and Description |
---|---|
static <T> Expression<T> |
ExpressionUtils.list(Class<T> clazz,
List<? extends Expression<?>> exprs) |
Set<Expression<?>> |
ValidatingVisitor.visit(Constant<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(FactoryExpression<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(Operation<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(ParamExpression<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(Path<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(SubQueryExpression<?> expr,
Set<Expression<?>> known) |
Set<Expression<?>> |
ValidatingVisitor.visit(TemplateExpression<?> expr,
Set<Expression<?>> known) |
static FactoryExpression<?> |
FactoryExpressionUtils.wrap(List<? extends Expression<?>> projection) |
Constructor and Description |
---|
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) |
OrderSpecifier(Order order,
Expression<T> target,
OrderSpecifier.NullHandling nullhandling) |
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
|
QList(Expression<?>... args)
Create a new QList instance
|
QList(Expression<?>[]... args)
Create a new QMap instance
|
QMap(Expression<?>... args)
Create a new QMap instance
|
QMap(Expression<?>[]... args)
Create a new QMap instance
|
QTuple(Expression<?>... args)
Create a new QTuple instance
|
QTuple(Expression<?>[]... args)
Create a new QTuple instance
|
Constructor and Description |
---|
ConstructorExpression(Class<T> type,
Class<?>[] paramTypes,
com.google.common.collect.ImmutableList<Expression<?>> args) |
OperationImpl(Class<? extends T> type,
Operator<? super T> operator,
com.google.common.collect.ImmutableList<Expression<?>> args) |
PredicateOperation(Operator<Boolean> operator,
com.google.common.collect.ImmutableList<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
|
QList(com.google.common.collect.ImmutableList<Expression<?>> args)
Create a new QList instance
|
QMap(com.google.common.collect.ImmutableList<Expression<?>> args)
Create a new QMap instance
|
QTuple(com.google.common.collect.ImmutableList<Expression<?>> args)
Create a new QTuple instance
|
Modifier and Type | Class and Description |
---|---|
static class |
CaseBuilder.Cases<A,Q extends Expression<A>>
Cascading typesafe Case builder
|
static class |
CaseBuilder.CaseWhen<A,Q extends Expression<A>>
Intermediate When state
|
class |
CaseForEqBuilder.Cases<T,Q extends Expression<T>> |
class |
CaseForEqBuilder.CaseWhen<T,Q extends Expression<T>> |
Modifier and Type | Interface and Description |
---|---|
interface |
ArrayExpression<A,T>
ArrayExpression defines an interface for array typed expression
|
interface |
ListExpression<E,Q extends SimpleExpression<? super E>>
ListExpression represents
List typed expressions |
Modifier and Type | Class and Description |
---|---|
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
|
Modifier and Type | Field and Description |
---|---|
static Expression<Object[]> |
Wildcard.all
Wilcard expression (*) for all columns
|
protected Expression<T> |
DslExpression.mixin |
Modifier and Type | Method and Description |
---|---|
Expression<?> |
NumberOperation.getArg(int index) |
Expression<?> |
DateTimeOperation.getArg(int index) |
Expression<?> |
StringOperation.getArg(int index) |
Expression<?> |
BooleanOperation.getArg(int index) |
Expression<?> |
TimeOperation.getArg(int index) |
Expression<?> |
EnumOperation.getArg(int index) |
Expression<?> |
ComparableOperation.getArg(int index) |
Expression<?> |
DslOperation.getArg(int index) |
Expression<?> |
SimpleOperation.getArg(int index) |
Expression<?> |
DateOperation.getArg(int index) |
Modifier and Type | Method and Description |
---|---|
List<Expression<?>> |
NumberOperation.getArgs() |
List<Expression<?>> |
DateTimeOperation.getArgs() |
List<Expression<?>> |
StringOperation.getArgs() |
List<Expression<?>> |
BooleanOperation.getArgs() |
List<Expression<?>> |
TimeOperation.getArgs() |
List<Expression<?>> |
EnumOperation.getArgs() |
List<Expression<?>> |
ComparableOperation.getArgs() |
List<Expression<?>> |
DslOperation.getArgs() |
List<Expression<?>> |
SimpleOperation.getArgs() |
List<Expression<?>> |
DateOperation.getArgs() |
<A> CaseBuilder.Cases<A,Expression<A>> |
CaseBuilder.Initial.then(A constant) |
<A> CaseBuilder.Cases<A,Expression<A>> |
CaseBuilder.Initial.then(Expression<A> expr) |
<T> CaseForEqBuilder.Cases<T,Expression<T>> |
CaseForEqBuilder.then(Expression<T> then) |
<T> CaseForEqBuilder.Cases<T,Expression<T>> |
CaseForEqBuilder.then(T then) |
<T> CaseForEqBuilder.Cases<T,Expression<T>> |
CaseForEqBuilder.thenNull() |
Modifier and Type | Method and Description |
---|---|
static <A extends Number & Comparable<?>> |
MathExpressions.acos(Expression<A> num) |
<N extends Number & Comparable<?>> |
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 <A extends Number & Comparable<?>> |
MathExpressions.asin(Expression<A> num) |
static <A extends Number & Comparable<?>> |
MathExpressions.atan(Expression<A> num) |
BooleanExpression |
TemporalExpression.before(Expression<T> right)
Get a
this < right expression |
<A extends Number & Comparable<?>> |
NumberExpression.between(Expression<A> from,
Expression<A> to)
Create a
from < this < to expression |
<A extends Number & Comparable<?>> |
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 <A extends Number & Comparable<?>> |
MathExpressions.cos(Expression<A> num) |
static <A extends Number & Comparable<?>> |
MathExpressions.cosh(Expression<A> num) |
static <A extends Number & Comparable<?>> |
MathExpressions.cot(Expression<A> num) |
static <A extends Number & Comparable<?>> |
MathExpressions.coth(Expression<A> num) |
static <D extends Enum<D>> |
EnumOperation.create(Class<? extends D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D extends Number & Comparable<?>> |
NumberOperation.create(Class<? extends D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D extends Enum<D>> |
EnumOperation.create(Class<? extends D> type,
Operator<? super D> op,
Expression<?> one) |
static <D extends Number & Comparable<?>> |
NumberOperation.create(Class<? extends D> type,
Operator<? super D> op,
Expression<?> one) |
static <D extends Enum<D>> |
EnumOperation.create(Class<? extends D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends Enum<D>> |
EnumOperation.create(Class<? extends D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends Number & Comparable<?>> |
NumberOperation.create(Class<? extends D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends Number & Comparable<?>> |
NumberOperation.create(Class<? extends D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D> DslExpression<D> |
DslOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D> SimpleExpression<D> |
SimpleOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D extends Comparable<?>> |
DateTimeOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D extends Comparable<?>> |
TimeOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D extends Comparable<?>> |
ComparableOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D extends Comparable<?>> |
DateOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D> DslExpression<D> |
DslOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one) |
static <D> SimpleExpression<D> |
SimpleOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one) |
static <D extends Comparable<?>> |
DateTimeOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one) |
static <D extends Comparable<?>> |
TimeOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one) |
static <D extends Comparable<?>> |
DateOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one) |
static <D> DslExpression<D> |
DslOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D> DslExpression<D> |
DslOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D> SimpleExpression<D> |
SimpleOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D> SimpleExpression<D> |
SimpleOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends Comparable<?>> |
DateTimeOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends Comparable<?>> |
DateTimeOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends Comparable<?>> |
TimeOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends Comparable<?>> |
TimeOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends Comparable<?>> |
DateOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends Comparable<?>> |
DateOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static BooleanExpression |
BooleanOperation.create(Operator<? super Boolean> op,
Expression<?>... args) |
static BooleanExpression |
BooleanOperation.create(Operator<? super Boolean> op,
Expression<?> one) |
static BooleanExpression |
BooleanOperation.create(Operator<? super Boolean> op,
Expression<?> one,
Expression<?> two) |
static BooleanExpression |
BooleanOperation.create(Operator<? super Boolean> op,
Expression<?> one,
Expression<?> two) |
static StringExpression |
StringOperation.create(Operator<? super String> op,
Expression<?>... args) |
static StringExpression |
StringOperation.create(Operator<? super String> op,
Expression<?> one) |
static StringExpression |
StringOperation.create(Operator<? super String> op,
Expression<?> one,
Expression<?> two) |
static StringExpression |
StringOperation.create(Operator<? super String> op,
Expression<?> one,
Expression<?> two) |
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 <A extends Number & Comparable<?>> |
MathExpressions.degrees(Expression<A> num) |
<N extends Number & Comparable<?>> |
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 <A extends Number & Comparable<?>> |
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) |
<A extends Number & Comparable<?>> |
NumberExpression.goe(Expression<A> right)
Create a
this >= right expression |
BooleanExpression |
ComparableExpression.goe(Expression<T> right)
Get a
this >= right expression |
<A extends Number & Comparable<?>> |
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 |
NumberExpression.like(Expression<String> str)
Expr:
this like str |
BooleanExpression |
StringExpression.like(Expression<String> str)
Expr:
this like str |
BooleanExpression |
StringExpression.like(Expression<String> str,
char escape)
Expr:
this like str |
static <A extends Number & Comparable<?>> |
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
|
<A extends Number & Comparable<?>> |
NumberExpression.loe(Expression<A> right)
Create a
this <= right expression |
BooleanExpression |
ComparableExpression.loe(Expression<T> right)
Get a
this < right expression |
static <A extends Number & Comparable<?>> |
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) |
<A extends Number & Comparable<?>> |
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 <A extends Number & Comparable<?>> |
MathExpressions.max(Expression<A> left,
Expression<A> right)
Return the greater of the given values
|
static <A extends Number & Comparable<?>> |
MathExpressions.max(Expression<A> left,
Expression<A> right)
Return the greater of the given values
|
static <A extends Number & Comparable<?>> |
NumberExpression.max(Expression<A> left,
Expression<A> right)
Return the greater of the given values
|
static <A extends Number & Comparable<?>> |
NumberExpression.max(Expression<A> left,
Expression<A> right)
Return the greater of the given values
|
static <A extends Number & Comparable<?>> |
MathExpressions.min(Expression<A> left,
Expression<A> right)
Return the smaller of the given values
|
static <A extends Number & Comparable<?>> |
MathExpressions.min(Expression<A> left,
Expression<A> right)
Return the smaller of the given values
|
static <A extends Number & Comparable<?>> |
NumberExpression.min(Expression<A> left,
Expression<A> right)
Return the smaller of the given values
|
static <A extends Number & Comparable<?>> |
NumberExpression.min(Expression<A> left,
Expression<A> right)
Return the smaller of the given values
|
NumberExpression<T> |
NumberExpression.mod(Expression<T> num) |
<N extends Number & Comparable<?>> |
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 |
<A extends Number & Comparable<?>> |
NumberExpression.notBetween(Expression<A> from,
Expression<A> to) |
<A extends Number & Comparable<?>> |
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 |
SimpleExpression<T> |
SimpleExpression.nullif(Expression<T> other)
Get a
nullif(this, other) expression |
Q |
CaseBuilder.Cases.otherwise(Expression<A> expr) |
Q |
CaseForEqBuilder.Cases.otherwise(Expression<T> otherwise) |
static <A extends Number & Comparable<?>> |
MathExpressions.power(Expression<A> num,
int exponent) |
StringExpression |
StringExpression.prepend(Expression<String> str)
Prepend the given String and return the result
|
static <A extends Number & Comparable<?>> |
MathExpressions.radians(Expression<A> num) |
static <A extends Number & Comparable<?>> |
MathExpressions.round(Expression<A> num)
Round to nearest integer
|
static <A extends Number & Comparable<?>> |
MathExpressions.round(Expression<A> num,
int s)
Round to s decimal places
|
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 <A extends Number & Comparable<?>> |
MathExpressions.sign(Expression<A> num) |
static <A extends Number & Comparable<?>> |
MathExpressions.sin(Expression<A> num) |
static <A extends Number & Comparable<?>> |
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
|
<N extends Number & Comparable<?>> |
NumberExpression.subtract(Expression<N> right)
Get the difference of this and right
|
static <A extends Number & Comparable<?>> |
MathExpressions.tan(Expression<A> num) |
static <A extends Number & Comparable<?>> |
MathExpressions.tanh(Expression<A> num) |
CaseBuilder.Cases<A,Q> |
CaseBuilder.CaseWhen.then(Expression<A> expr) |
<A> CaseBuilder.Cases<A,Expression<A>> |
CaseBuilder.Initial.then(Expression<A> expr) |
CaseForEqBuilder.Cases<T,Q> |
CaseForEqBuilder.CaseWhen.then(Expression<T> then) |
<T> CaseForEqBuilder.Cases<T,Expression<T>> |
CaseForEqBuilder.then(Expression<T> then) |
<T extends Number & Comparable<?>> |
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 and Description |
---|
BooleanOperation(Operator<? super Boolean> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
ComparableOperation(Class<T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
DateOperation(Class<T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
DateTimeOperation(Class<T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
DslOperation(Class<T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
EnumOperation(Class<? extends T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
NumberOperation(Class<? extends T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
SimpleOperation(Class<T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
StringOperation(Operator<? super String> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
TimeOperation(Class<T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
Modifier and Type | Class and Description |
---|---|
class |
ArrayPath<A,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
|
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Interface and Description |
---|---|
interface |
ExtendedSubQueryExpression<T>
Extensions to the SubQueryExpression interface
|
Modifier and Type | Class and Description |
---|---|
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
|
Modifier and Type | Method and Description |
---|---|
SimpleExpression<?> |
ListSubQuery.as(Expression<?> alias) |
Modifier and Type | Class and Description |
---|---|
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
|
Copyright © 2007–2013 Mysema Ltd. All rights reserved.