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.spatial | |
com.mysema.query.spatial.path | |
com.mysema.query.sql |
SQL/JDBC support for Querydsl
|
com.mysema.query.sql.dml |
DML operations support
|
com.mysema.query.sql.mysql |
MySQL support
|
com.mysema.query.sql.oracle |
Oracle support for Querydsl SQL
|
com.mysema.query.sql.spatial | |
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 |
MixinGroupExpression<E,F,R> |
class |
QPair<K,V>
A pair of (Map) key and value
|
Modifier and Type | Method and Description |
---|---|
Expression<T> |
AbstractGroupExpression.getExpression() |
Expression<T> |
GroupExpression.getExpression() |
Modifier and Type | Method and Description |
---|---|
ResultTransformer<Map<K,Group>> |
GroupByBuilder.as(Expression<?>... expressions)
Get the results as a map
|
<V> ResultTransformer<Map<K,V>> |
GroupByBuilder.as(Expression<V> expression)
Get the results as a map
|
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
|
ResultTransformer<com.mysema.commons.lang.CloseableIterator<Group>> |
GroupByBuilder.iterate(Expression<?>... expressions)
Get the results as a closeable iterator
|
<V> ResultTransformer<com.mysema.commons.lang.CloseableIterator<V>> |
GroupByBuilder.iterate(Expression<V> expression)
Get the results as a closeable iterator
|
ResultTransformer<List<Group>> |
GroupByBuilder.list(Expression<?>... expressions)
Get the results as a list
|
static <E> AbstractGroupExpression<E,List<E>> |
GroupBy.list(Expression<E> expression)
Create a new aggregating list expression
|
<V> ResultTransformer<List<V>> |
GroupByBuilder.list(Expression<V> expression)
Get the results as a list
|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<K,V>> |
GroupBy.map(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression
|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<K,V>> |
GroupBy.map(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression
|
static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<K,U>> |
GroupBy.map(Expression<K> key,
GroupExpression<V,U> value) |
static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,Map<T,V>> |
GroupBy.map(GroupExpression<K,T> key,
Expression<V> value) |
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<E,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 |
---|---|
com.mysema.commons.lang.CloseableIterator<Tuple> |
AbstractSQLQuery.iterate(Expression<?>... args) |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
AbstractSQLQuery.iterate(Expression<RT> projection) |
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) |
Tuple |
AbstractSQLQuery.uniqueResult(Expression<?>... args) |
<RT> RT |
AbstractSQLQuery.uniqueResult(Expression<RT> expr) |
Modifier and Type | Method and Description |
---|---|
static <RT> Expression<RT> |
Conversions.convert(Expression<RT> expr) |
<RT> Expression<RT> |
JPAQueryMixin.convert(Expression<RT> expr,
boolean forOrder) |
static <RT> Expression<RT> |
Conversions.convertForNativeQuery(Expression<RT> expr) |
protected <D> Expression<D> |
JPAQueryMixin.createAlias(Expression<?> expr,
Path<?> alias) |
protected Expression<?> |
AbstractSQLQuery.extractEntityExpression(Expression<?> expr) |
Modifier and Type | Method and Description |
---|---|
Map<Expression<?>,String> |
NativeSQLSerializer.getAliases() |
Modifier and Type | Method and Description |
---|---|
static <RT> Expression<RT> |
Conversions.convert(Expression<RT> expr) |
<RT> Expression<RT> |
JPAQueryMixin.convert(Expression<RT> expr,
boolean forOrder) |
static <RT> Expression<RT> |
Conversions.convertForNativeQuery(Expression<RT> expr) |
protected <D> Expression<D> |
JPAQueryMixin.createAlias(Expression<?> expr,
Path<?> alias) |
protected Expression<?> |
AbstractSQLQuery.extractEntityExpression(Expression<?> expr) |
protected boolean |
AbstractSQLQuery.isEntityExpression(Expression<?> expr) |
Tuple |
JPAQueryBase.uniqueResult(Expression<?>... args) |
Modifier and Type | Method and Description |
---|---|
protected void |
JPQLSerializer.visitOperation(Class<?> type,
Operator<?> operator,
List<? extends Expression<?>> args) |
protected void |
NativeSQLSerializer.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) |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
AbstractHibernateSQLQuery.iterate(Expression<RT> projection) |
<RT> List<RT> |
AbstractHibernateSQLQuery.list(Expression<RT> projection) |
<RT> SearchResults<RT> |
AbstractHibernateSQLQuery.listResults(Expression<RT> projection) |
<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) |
<RT> RT |
AbstractJPAQuery.uniqueResult(Expression<RT> expr) |
Modifier and Type | Method and Description |
---|---|
javax.persistence.Query |
AbstractJPASQLQuery.createQuery(Expression<?>... args) |
<RT> com.mysema.commons.lang.CloseableIterator<RT> |
AbstractJPASQLQuery.iterate(Expression<RT> expr) |
<RT> List<RT> |
AbstractJPASQLQuery.list(Expression<RT> projection) |
<RT> SearchResults<RT> |
AbstractJPASQLQuery.listResults(Expression<RT> projection) |
<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 | Class and Description |
---|---|
class |
CurveExpression<T extends org.geolatte.geom.Geometry>
A Curve is a 1-dimensional geometric object usually stored as a sequence of Points, with the subtype of Curve
specifying the form of the interpolation between Points.
|
class |
GeometryCollectionExpression<T extends org.geolatte.geom.GeometryCollection>
A GeometryCollection is a geometric object that is a collection of some number of geometric objects.
|
class |
GeometryExpression<T extends org.geolatte.geom.Geometry>
Geometry is the root class of the hierarchy.
|
class |
GeometryOperation<T extends org.geolatte.geom.Geometry> |
class |
LinearRingExpression<T extends org.geolatte.geom.LineString>
A LinearRing is a LineString that is both closed and simple.
|
class |
LineExpression<T extends org.geolatte.geom.LineString>
A Line is a LineString with exactly 2 Points.
|
class |
LineStringExpression<T extends org.geolatte.geom.LineString>
A LineString is a Curve with linear interpolation between Points.
|
class |
LineStringOperation<T extends org.geolatte.geom.LineString> |
class |
MultiCurveExpression<T extends org.geolatte.geom.GeometryCollection>
A MultiCurve is a 1-dimensional GeometryCollection whose elements are Curves.
|
class |
MultiLineStringExpression<T extends org.geolatte.geom.MultiLineString>
A MultiLineString is a MultiCurve whose elements are LineStrings.
|
class |
MultiPointExpression<T extends org.geolatte.geom.MultiPoint>
A MultiPoint is a 0-dimensional GeometryCollection.
|
class |
MultiPolygonExpression<T extends org.geolatte.geom.MultiPolygon>
A MultiPolygon is a MultiSurface whose elements are Polygons.
|
class |
MultiSurfaceExpression<T extends org.geolatte.geom.GeometryCollection>
A MultiSurface is a 2-dimensional GeometryCollection whose elements are Surfaces, all using coordinates from
the same coordinate reference system.
|
class |
PointExpression<T extends org.geolatte.geom.Point>
A Point is a 0-dimensional geometric object and represents a single location in coordinate space.
|
class |
PointOperation<T extends org.geolatte.geom.Point> |
class |
PolygonExpression<T extends org.geolatte.geom.Polygon>
A Polygon is a planar Surface defined by 1 exterior boundary and 0 or more interior boundaries.
|
class |
PolygonOperation<T extends org.geolatte.geom.Polygon> |
class |
PolyhedralSurfaceExpression<T extends org.geolatte.geom.PolyHedralSurface>
A PolyhedralSurface is a contiguous collection of polygons, which share common boundary segments.
|
class |
SurfaceExpression<T extends org.geolatte.geom.Geometry>
A Surface is a 2-dimensional geometric object.
|
Modifier and Type | Method and Description |
---|---|
Expression<?> |
PointOperation.getArg(int index) |
Expression<?> |
LineStringOperation.getArg(int index) |
Expression<?> |
GeometryOperation.getArg(int index) |
Expression<?> |
PolygonOperation.getArg(int index) |
Modifier and Type | Method and Description |
---|---|
List<Expression<?>> |
PointOperation.getArgs() |
List<Expression<?>> |
LineStringOperation.getArgs() |
List<Expression<?>> |
GeometryOperation.getArgs() |
List<Expression<?>> |
PolygonOperation.getArgs() |
Modifier and Type | Method and Description |
---|---|
static GeometryExpression<?> |
GeometryExpressions.collect(Expression<? extends org.geolatte.geom.Geometry> expr1,
Expression<? extends org.geolatte.geom.Geometry> expr2)
Return a specified ST_Geometry value from a collection of other geometries.
|
static GeometryExpression<?> |
GeometryExpressions.collect(Expression<? extends org.geolatte.geom.Geometry> expr1,
Expression<? extends org.geolatte.geom.Geometry> expr2)
Return a specified ST_Geometry value from a collection of other geometries.
|
static GeometryExpression<?> |
GeometryExpressions.collect(Expression<? extends org.geolatte.geom.GeometryCollection> collection)
Return a specified ST_Geometry value from a collection of other geometries.
|
BooleanExpression |
GeometryExpression.contains(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially contains” anotherGeometry.
|
static <D extends org.geolatte.geom.Geometry> |
GeometryOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D extends org.geolatte.geom.LineString> |
LineStringOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D extends org.geolatte.geom.Point> |
PointOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D extends org.geolatte.geom.Polygon> |
PolygonOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D extends org.geolatte.geom.Geometry> |
GeometryOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one) |
static <D extends org.geolatte.geom.LineString> |
LineStringOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one) |
static <D extends org.geolatte.geom.Point> |
PointOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one) |
static <D extends org.geolatte.geom.Polygon> |
PolygonOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one) |
static <D extends org.geolatte.geom.Geometry> |
GeometryOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends org.geolatte.geom.Geometry> |
GeometryOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends org.geolatte.geom.LineString> |
LineStringOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends org.geolatte.geom.LineString> |
LineStringOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends org.geolatte.geom.Point> |
PointOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends org.geolatte.geom.Point> |
PointOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends org.geolatte.geom.Polygon> |
PolygonOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
static <D extends org.geolatte.geom.Polygon> |
PolygonOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
BooleanExpression |
GeometryExpression.crosses(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially crosses’ anotherGeometry.
|
GeometryExpression<org.geolatte.geom.Geometry> |
GeometryExpression.difference(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns a geometric object that represents the Point
set difference of this geometric object with anotherGeometry.
|
BooleanExpression |
GeometryExpression.disjoint(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object is “spatially disjoint” from anotherGeometry.
|
NumberExpression<Double> |
GeometryExpression.distance(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns the shortest distance between any two Points in the two geometric objects as
calculated in the spatial reference system of this geometric object.
|
NumberExpression<Double> |
GeometryExpression.distanceSphere(Expression<? extends org.geolatte.geom.Geometry> geometry) |
NumberExpression<Double> |
GeometryExpression.distanceSpheroid(Expression<? extends org.geolatte.geom.Geometry> geometry) |
static BooleanExpression |
GeometryExpressions.dwithin(Expression<? extends org.geolatte.geom.Geometry> expr1,
Expression<? extends org.geolatte.geom.Geometry> expr2,
double distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
GeometryExpressions.dwithin(Expression<? extends org.geolatte.geom.Geometry> expr1,
Expression<? extends org.geolatte.geom.Geometry> expr2,
double distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
GeometryExpressions.dwithin(Expression<? extends org.geolatte.geom.Geometry> expr1,
Expression<? extends org.geolatte.geom.Geometry> expr2,
Expression<Double> distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
GeometryExpressions.dwithin(Expression<? extends org.geolatte.geom.Geometry> expr1,
Expression<? extends org.geolatte.geom.Geometry> expr2,
Expression<Double> distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
GeometryExpressions.dwithin(Expression<? extends org.geolatte.geom.Geometry> expr1,
Expression<? extends org.geolatte.geom.Geometry> expr2,
Expression<Double> distance)
Returns true if the geometries are within the specified distance of one another.
|
BooleanExpression |
GeometryExpression.eq(Expression<? super T> right) |
static GeometryExpression<?> |
GeometryExpressions.extent(Expression<? extends org.geolatte.geom.GeometryCollection> collection)
Returns the bounding box that bounds rows of geometries.
|
static GeometryExpression<?> |
GeometryExpressions.fromText(Expression<String> text)
Return a specified ST_Geometry value from Well-Known Text representation (WKT).
|
GeometryExpression<org.geolatte.geom.Geometry> |
GeometryExpression.intersection(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns a geometric object that represents the Point set intersection of this geometric
object with anotherGeometry.
|
BooleanExpression |
GeometryExpression.intersects(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially intersects” anotherGeometry.
|
BooleanExpression |
GeometryExpression.overlaps(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially overlaps” anotherGeometry.
|
BooleanExpression |
GeometryExpression.relate(Expression<? extends org.geolatte.geom.Geometry> geometry,
String matrix)
Returns 1 (TRUE) if this geometric object is spatially related to anotherGeometry by testing
for intersections between the interior, boundary and exterior of the two geometric objects
as specified by the values in the intersectionPatternMatrix.
|
static <T extends org.geolatte.geom.Geometry> |
GeometryExpressions.setSRID(Expression<T> expr,
int srid)
Sets the SRID on a geometry to a particular integer value.
|
GeometryExpression<org.geolatte.geom.Geometry> |
GeometryExpression.symDifference(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns a geometric object that represents the
Point set symmetric difference of this geometric object with anotherGeometry.
|
BooleanExpression |
GeometryExpression.touches(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially touches” anotherGeometry.
|
static <T extends org.geolatte.geom.Geometry> |
GeometryExpressions.translate(Expression<T> expr,
float deltax,
float deltay)
Translates the geometry to a new location using the numeric parameters as offsets.
|
static <T extends org.geolatte.geom.Geometry> |
GeometryExpressions.translate(Expression<T> expr,
float deltax,
float deltay,
float deltaz)
Translates the geometry to a new location using the numeric parameters as offsets.
|
GeometryExpression<org.geolatte.geom.Geometry> |
GeometryExpression.union(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns a geometric object that represents the Point set
union of this geometric object with anotherGeometry.
|
BooleanExpression |
GeometryExpression.within(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object is “spatially within” anotherGeometry.
|
Constructor and Description |
---|
GeometryOperation(Class<T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
LineStringOperation(Class<T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
PointOperation(Class<T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
PolygonOperation(Class<T> type,
Operator<? super T> op,
com.google.common.collect.ImmutableList<Expression<?>> args) |
Modifier and Type | Class and Description |
---|---|
class |
GeometryCollectionPath<T extends org.geolatte.geom.GeometryCollection> |
class |
GeometryPath<T extends org.geolatte.geom.Geometry> |
class |
LinearRingPath<T extends org.geolatte.geom.LinearRing> |
class |
LineStringPath<T extends org.geolatte.geom.LineString> |
class |
MultiLineStringPath<T extends org.geolatte.geom.MultiLineString> |
class |
MultiPointPath<T extends org.geolatte.geom.MultiPoint> |
class |
MultiPolygonPath<T extends org.geolatte.geom.MultiPolygon> |
class |
PointPath<T extends org.geolatte.geom.Point> |
class |
PolygonPath<T extends org.geolatte.geom.Polygon> |
class |
PolyhedralSurfacePath<T extends org.geolatte.geom.PolyHedralSurface> |
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 |
WindowFirstLast<T> |
class |
WindowFunction<A> |
class |
WindowOver<T>
WindowOver is the first part of a WindowFunction construction
|
class |
WithinGroup<T> |
class |
WithinGroup.OrderBy |
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<?> |
ProjectableSQLQuery.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 |
DetachableSQLQuery.addFlag(QueryFlag.Position position,
Expression<?> flag)
Add the given Expression as a query flag
|
Q |
ProjectableSQLQuery.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 |
DetachableSQLQuery.addFlag(QueryFlag.Position position,
String prefix,
Expression<?> expr)
Add the given prefix and expression as a general query flag
|
Q |
ProjectableSQLQuery.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)
Start a window function expression
|
static WindowOver<Double> |
SQLExpressions.corr(Expression<? extends Number> expr1,
Expression<? extends Number> expr2) |
static WindowOver<Double> |
SQLExpressions.corr(Expression<? extends Number> expr1,
Expression<? extends Number> expr2) |
static WindowOver<Long> |
SQLExpressions.count(Expression<?> expr)
Start a window function expression
|
static WindowOver<Long> |
SQLExpressions.countDistinct(Expression<?> expr)
Start a window function expression
|
static WindowOver<Double> |
SQLExpressions.covarPop(Expression<? extends Number> expr1,
Expression<? extends Number> expr2) |
static WindowOver<Double> |
SQLExpressions.covarPop(Expression<? extends Number> expr1,
Expression<? extends Number> expr2) |
static WindowOver<Double> |
SQLExpressions.covarSamp(Expression<? extends Number> expr1,
Expression<? extends Number> expr2) |
static WindowOver<Double> |
SQLExpressions.covarSamp(Expression<? extends Number> expr1,
Expression<? extends Number> expr2) |
static WithinGroup<Double> |
SQLExpressions.cumeDist(Expression<?>... args) |
static WithinGroup<Long> |
SQLExpressions.denseRank(Expression<?>... args) |
BooleanExpression |
RelationalPathBase.eq(Expression<? super T> right)
Compares the two relational paths using primary key columns
|
BooleanExpression |
WindowFunction.eq(Expression<A> 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
|
WindowRows.BetweenAnd |
WindowRows.Between.following(Expression<Integer> expr) |
WindowFunction<A> |
WindowRows.BetweenAnd.following(Expression<Integer> expr) |
Q |
DetachableSQLQuery.from(Expression<?>... args) |
Q |
ProjectableSQLQuery.from(Expression<?>... args) |
Q |
AbstractSQLQueryFactory.from(Expression<?>... args) |
Q |
SQLCommonQueryFactory.from(Expression<?>... from)
Create a new SELECT query
|
Q |
SQLCommonQuery.from(Expression<?>... o)
Defines the sources of the query
|
Q |
DetachableSQLQuery.from(Expression<?> arg) |
Q |
ProjectableSQLQuery.from(Expression<?> arg) |
Q |
AbstractSQLQueryFactory.from(Expression<?> from) |
Q |
SQLCommonQueryFactory.from(Expression<?> from)
Create a new SELECT query
|
ResultSet |
AbstractSQLQuery.getResults(Expression<?>... exprs)
Get the results as an JDBC result set
|
SQLBindings |
DetachableSQLQuery.getSQL(Expression<?>... exprs)
Get the query as an SQL query string and bindings
|
SQLBindings |
ProjectableSQLQuery.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> |
ProjectableSQLQuery.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)
Get the rhs leftmost characters of lhs
|
static StringExpression |
SQLExpressions.left(Expression<String> lhs,
Expression<Integer> rhs)
Get the rhs leftmost characters of lhs
|
static StringExpression |
SQLExpressions.left(Expression<String> lhs,
int rhs)
Get the rhs leftmost characters of lhs
|
List<Tuple> |
ProjectableSQLQuery.list(Expression<?>... args) |
<RT> List<RT> |
AbstractSQLQuery.list(Expression<RT> expr) |
static WithinGroup<Object> |
SQLExpressions.listagg(Expression<?> expr,
String delimiter) |
SearchResults<Tuple> |
ProjectableSQLQuery.listResults(Expression<?>... args) |
<RT> SearchResults<RT> |
AbstractSQLQuery.listResults(Expression<RT> expr) |
static <T extends Comparable> |
SQLExpressions.max(Expression<T> expr)
Start a window function expression
|
static <T extends Comparable> |
SQLExpressions.min(Expression<T> expr)
Start a window function expression
|
BooleanExpression |
RelationalPathBase.ne(Expression<? super T> right)
Compares the two relational paths using primary key columns
|
BooleanExpression |
WindowFunction.ne(Expression<A> expr) |
static <T> WindowOver<T> |
SQLExpressions.nthValue(Expression<T> measureExpr,
Expression<? extends Number> n) |
static <T> WindowOver<T> |
SQLExpressions.nthValue(Expression<T> measureExpr,
Expression<? extends Number> n) |
static <T> WindowOver<T> |
SQLExpressions.nthValue(Expression<T> measureExpr,
Number n) |
WindowFunction<A> |
WindowFunction.partitionBy(Expression<?>... partitionBy) |
WindowFunction<A> |
WindowFunction.partitionBy(Expression<?> partitionBy) |
static <T extends Number> |
SQLExpressions.percentileCont(Expression<T> arg) |
static <T extends Number> |
SQLExpressions.percentileDisc(Expression<T> arg) |
static WithinGroup<Double> |
SQLExpressions.percentRank(Expression<?>... args) |
WindowFunction<A> |
WindowRows.preceding(Expression<Integer> expr) |
WindowRows.BetweenAnd |
WindowRows.Between.preceding(Expression<Integer> expr) |
WindowFunction<A> |
WindowRows.BetweenAnd.preceding(Expression<Integer> expr) |
static WithinGroup<Long> |
SQLExpressions.rank(Expression<?>... args) |
static <T> WindowOver<T> |
SQLExpressions.ratioToReport(Expression<T> expr)
computes the ratio of a value to the sum of a set of values.
|
static WindowOver<Double> |
SQLExpressions.regrAvgx(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrAvgx(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrAvgy(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrAvgy(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrCount(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrCount(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrIntercept(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrIntercept(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrR2(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrR2(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrSlope(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrSlope(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrSxx(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrSxx(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrSxy(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrSxy(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrSyy(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static WindowOver<Double> |
SQLExpressions.regrSyy(Expression<? extends Number> arg1,
Expression<? extends Number> arg2) |
static StringExpression |
SQLExpressions.right(Expression<String> lhs,
Expression<Integer> rhs)
Get the rhs leftmost characters of lhs
|
static StringExpression |
SQLExpressions.right(Expression<String> lhs,
Expression<Integer> rhs)
Get the rhs leftmost characters of lhs
|
static StringExpression |
SQLExpressions.right(Expression<String> lhs,
int rhs)
Get the rhs rightmost characters of lhs
|
void |
SQLSerializer.serializeUnion(Expression<?> union,
QueryMetadata metadata,
boolean unionAll) |
static <T extends Number> |
SQLExpressions.stddev(Expression<T> expr)
returns the sample standard deviation of expr, a set of numbers.
|
static <T extends Number> |
SQLExpressions.stddevDistinct(Expression<T> expr) |
static <T extends Number> |
SQLExpressions.stddevPop(Expression<T> expr)
returns the population standard deviation and returns the square root of the population variance.
|
static <T extends Number> |
SQLExpressions.stddevSamp(Expression<T> expr)
returns the cumulative sample standard deviation and returns the square root of the sample variance.
|
SQ |
AbstractSQLQueryFactory.subQuery(Expression<?> from) |
SQ |
SQLCommonQueryFactory.subQuery(Expression<?> from) |
static <T extends Number> |
SQLExpressions.sum(Expression<T> expr)
Start a window function expression
|
Tuple |
ProjectableSQLQuery.uniqueResult(Expression<?>... args) |
<RT> RT |
AbstractSQLQuery.uniqueResult(Expression<RT> expr) |
<RT> RT |
ProjectableSQLQuery.uniqueResult(Expression<RT> expr) |
static <T extends Number> |
SQLExpressions.variance(Expression<T> expr)
returns the variance of expr
|
static <T extends Number> |
SQLExpressions.varPop(Expression<T> expr)
returns the population variance of a set of numbers after discarding the nulls in this set.
|
static <T extends Number> |
SQLExpressions.varSamp(Expression<T> expr)
returns the sample variance of a set of numbers after discarding the nulls in this set.
|
Q |
DetachableSQLQuery.with(Path<?> alias,
Expression<?> query) |
Q |
ProjectableSQLQuery.with(Path<?> alias,
Expression<?> query) |
Q |
SQLCommonQuery.with(Path<?> alias,
Expression<?> query)
Adds a common table expression
|
Q |
DetachableSQLQuery.withRecursive(Path<?> alias,
Expression<?> query) |
Q |
ProjectableSQLQuery.withRecursive(Path<?> alias,
Expression<?> query) |
Q |
SQLCommonQuery.withRecursive(Path<?> alias,
Expression<?> query)
Adds a common table expression
|
Modifier and Type | Method and Description |
---|---|
void |
SQLListener.notifyInsert(RelationalPath<?> entity,
QueryMetadata md,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery)
Notify about an insertion
|
void |
SQLListeners.notifyInsert(RelationalPath<?> entity,
QueryMetadata md,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLListener.notifyMerge(RelationalPath<?> entity,
QueryMetadata md,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery)
Notify about a merge
|
void |
SQLListeners.notifyMerge(RelationalPath<?> entity,
QueryMetadata md,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLListener.notifyUpdate(RelationalPath<?> entity,
QueryMetadata md,
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates)
Notify about an update operation
|
void |
SQLListeners.notifyUpdate(RelationalPath<?> entity,
QueryMetadata md,
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates) |
void |
SQLSerializer.serializeInsert(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLTemplates.serializeInsert(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery,
SQLSerializer context)
template method for INSERT serialization
|
void |
SQLSerializer.serializeMerge(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLTemplates.serializeMerge(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery,
SQLSerializer context)
template method for MERGE serialization
|
void |
SQLSerializer.serializeUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates) |
void |
SQLTemplates.serializeUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates,
SQLSerializer context)
template method for UPDATE serialization
|
void |
SQLServer2005Templates.serializeUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates,
SQLSerializer context) |
void |
OracleTemplates.serializeUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates,
SQLSerializer context) |
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) |
WindowOver(Class<T> type,
Operator<? super T> op,
Expression<?> arg1,
Expression<?> arg2) |
WindowOver(Class<T> type,
Operator<? super T> op,
Expression<?> arg1,
Expression<?> arg2) |
WithBuilder(QueryMixin<R> queryMixin,
Expression<?> alias) |
WithinGroup(Class<T> type,
Operator<? super T> op,
Expression<?>... args) |
WithinGroup(Class<T> type,
Operator<? super T> op,
Expression<?> arg) |
WithinGroup(Class<T> type,
Operator<? super T> op,
Expression<?> arg1,
Expression<?> arg2) |
WithinGroup(Class<T> type,
Operator<? super T> op,
Expression<?> arg1,
Expression<?> arg2) |
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 | Method and Description |
---|---|
SQLInsertClause |
MySQLQueryFactory.insertOnDuplicateKeyUpdate(RelationalPath<?> entity,
Expression<?> clause) |
Modifier and Type | Method and Description |
---|---|
OracleQuery |
OracleQuery.orderSiblingsBy(Expression<?> path) |
Modifier and Type | Class and Description |
---|---|
class |
QSpatialRefSys
QSpatialRefSys is a Querydsl query type for SpatialRefSys
|
class |
RelationalPathSpatial<T> |
Modifier and Type | Class and Description |
---|---|
class |
EnumConversion<T>
EnumConversion ensures that the results of an enum projection confirm to the type of the
projection expression
|
class |
NumberConversion<T>
NumberConversion ensures that the results of a numeric projection confirm to the type of the
projection expression
|
class |
NumberConversions<T>
NumberConversions ensures that the results of a projection involving numeric expressions
confirm to the types of the numeric expressions
|
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,
boolean forOrder) |
protected <D> Expression<D> |
QueryMixin.createAlias(Expression<?> expr,
Path<?> alias) |
Expression<Tuple> |
QueryMixin.createProjection(Expression<?>[] args) |
Expression<?> |
ListAccessVisitor.visit(Constant<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(Constant<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(Constant<?> expr,
Void context) |
Expression<?> |
ListAccessVisitor.visit(FactoryExpression<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(FactoryExpression<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(FactoryExpression<?> expr,
Void context) |
Expression<?> |
ListAccessVisitor.visit(Operation<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(Operation<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(Operation<?> expr,
Void context) |
Expression<?> |
ListAccessVisitor.visit(ParamExpression<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(ParamExpression<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(ParamExpression<?> expr,
Void context) |
Expression<?> |
ListAccessVisitor.visit(Path<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(Path<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(Path<?> expr,
Void context) |
Expression<?> |
ListAccessVisitor.visit(SubQueryExpression<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(SubQueryExpression<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(SubQueryExpression<?> expr,
Void context) |
Expression<?> |
ListAccessVisitor.visit(TemplateExpression<?> expr,
Context context) |
Expression<?> |
CollectionAnyVisitor.visit(TemplateExpression<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(TemplateExpression<?> expr,
Void context) |
Modifier and Type | Method and Description |
---|---|
List<Expression<?>> |
NumberConversion.getArgs() |
List<Expression<?>> |
NumberConversions.getArgs() |
List<Expression<?>> |
EnumConversion.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,
boolean forOrder) |
protected <D> Expression<D> |
QueryMixin.createAlias(Expression<?> expr,
Path<?> alias) |
Expression<Tuple> |
QueryMixin.createProjection(Expression<?>[] args) |
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 |
---|
EnumConversion(Expression<T> expr) |
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 |
class |
FactoryExpressionBase<T>
Common superclass for FactoryExpression 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)
Get the potentially wrapped expression
|
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)
Get a distinct list of the given args
|
static com.google.common.collect.ImmutableList<Expression<?>> |
ExpressionUtils.distinctList(Expression<?>[]... args)
Get a distinct list of the concatenated array contents
|
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)
Get a distinct list of the given args
|
static com.google.common.collect.ImmutableList<Expression<?>> |
ExpressionUtils.distinctList(Expression<?>[]... args)
Get a distinct list of the concatenated array contents
|
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)
Get the potentially wrapped expression
|
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
|
protected void |
QBean.propertyNotFound(Expression<?> expr,
String property) |
static Expression<String> |
ExpressionUtils.regexToLike(Expression<String> expr) |
static QTuple |
Projections.tuple(Expression<?>... exprs)
Create a Tuple typed projection for the given expressions
|
protected void |
QBean.typeMismatch(Class<?> type,
Expression<?> expr) |
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 <T> FactoryExpression<T> |
FactoryExpressionUtils.wrap(FactoryExpression<T> expr,
List<Expression<?>> conversions) |
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 |
CollectionOperation<E> |
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() |
<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 <E> CollectionOperation<E> |
CollectionOperation.create(Operator<?> op,
Class<E> type,
Expression<?>... args) |
static <E> CollectionOperation<E> |
CollectionOperation.create(Operator<?> op,
Class<E> type,
Expression<?> one) |
static <E> CollectionOperation<E> |
CollectionOperation.create(Operator<?> op,
Class<E> type,
Expression<?> one,
Expression<?> two) |
static <E> CollectionOperation<E> |
CollectionOperation.create(Operator<?> op,
Class<E> type,
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,SimpleExpression<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) |
CollectionOperation(Operator<?> op,
Class<? super E> type,
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–2014 Mysema Ltd. All rights reserved.