Package | Description |
---|---|
com.querydsl.apt |
APT-related classes
|
com.querydsl.collections |
Java Bean collections support
|
com.querydsl.core |
Basic Query elements
|
com.querydsl.core.alias |
Alias functionality
|
com.querydsl.core.dml |
DML interfaces
|
com.querydsl.core.group |
Aggregating post processing functionality
|
com.querydsl.core.group.guava |
Utilities for creating group by factory expressions for Guava collection types
|
com.querydsl.core.support |
Various support classes
|
com.querydsl.core.types |
Expression types
|
com.querydsl.core.types.dsl |
DSL expression types
|
com.querydsl.jdo |
JDO support
|
com.querydsl.jdo.dml |
DML operations support
|
com.querydsl.jdo.sql |
SQL queries for JDO
|
com.querydsl.jpa |
JPA support
|
com.querydsl.jpa.hibernate |
JPQL for Hibernate
|
com.querydsl.jpa.hibernate.sql |
Native queries for Hibernate
|
com.querydsl.jpa.impl |
JPQL for JPA
|
com.querydsl.jpa.sql |
Native queries for JPA
|
com.querydsl.lucene3 |
Lucene 3 support
|
com.querydsl.lucene4 |
Lucene 4 support
|
com.querydsl.lucene5 |
Lucene 5 support
|
com.querydsl.mongodb |
MongoDB support
|
com.querydsl.mongodb.document |
MongoDB Document API support.
|
com.querydsl.spatial |
Spatial types using Geolatte
|
com.querydsl.spatial.jts |
Spatial types using JTS
|
com.querydsl.spatial.locationtech.jts |
Spatial types using JTS
|
com.querydsl.sql |
SQL/JDBC support
|
com.querydsl.sql.dml |
DML operations support
|
com.querydsl.sql.mssql |
SQL Server support
|
com.querydsl.sql.mysql |
MySQL support
|
com.querydsl.sql.oracle |
Oracle support
|
com.querydsl.sql.postgresql |
PostgreSQL support
|
com.querydsl.sql.spatial |
Spatial support
|
com.querydsl.sql.teradata |
Teradata support
|
Modifier and Type | Method and Description |
---|---|
<T> void |
DefaultConfiguration.addCustomType(java.lang.Class<T> type,
java.lang.Class<? extends Expression<T>> queryType) |
Modifier and Type | Method and Description |
---|---|
static java.lang.Number |
CollQueryFunctions.aggregate(java.util.Collection<java.lang.Number> source,
Expression<?> expr,
Operator aggregator) |
<T> Evaluator<T> |
DefaultEvaluatorFactory.create(QueryMetadata metadata,
java.util.List<? extends Expression<?>> sources,
Expression<T> projection)
Create an Evaluator for the given query sources and projection
|
<T> Evaluator<java.util.List<T>> |
DefaultEvaluatorFactory.createEvaluator(QueryMetadata metadata,
Expression<? extends T> source,
Predicate filter)
Create an Evaluator for the given source and filter
|
Q |
AbstractCollQuery.groupBy(Expression<?>... o) |
Q |
AbstractCollQuery.groupBy(Expression<?> e) |
<T> java.util.List<T> |
DefaultQueryEngine.list(QueryMetadata metadata,
java.util.Map<Expression<?>,java.lang.Iterable<?>> iterables,
Expression<T> projection) |
<T> java.util.List<T> |
QueryEngine.list(QueryMetadata metadata,
java.util.Map<Expression<?>,java.lang.Iterable<?>> iterables,
Expression<T> projection)
Evaluate the given query and return the projection as a list
|
CollQuery<Tuple> |
CollQuery.select(Expression<?>... exprs) |
<E> CollQuery<E> |
CollQuery.select(Expression<E> expr) |
<U> CollUpdateClause<T> |
CollUpdateClause.set(Path<U> path,
Expression<? extends U> expression) |
static <F,T> java.util.function.Function<F,T> |
FunctionalHelpers.wrap(Expression<T> projection)
Wrap a Querydsl expression into a Guava function
|
Modifier and Type | Method and Description |
---|---|
long |
DefaultQueryEngine.count(QueryMetadata metadata,
java.util.Map<Expression<?>,java.lang.Iterable<?>> iterables) |
long |
QueryEngine.count(QueryMetadata metadata,
java.util.Map<Expression<?>,java.lang.Iterable<?>> iterables)
Evaluate the given query and return the count of matched rows
|
<T> Evaluator<T> |
DefaultEvaluatorFactory.create(QueryMetadata metadata,
java.util.List<? extends Expression<?>> sources,
Expression<T> projection)
Create an Evaluator for the given query sources and projection
|
boolean |
DefaultQueryEngine.exists(QueryMetadata metadata,
java.util.Map<Expression<?>,java.lang.Iterable<?>> iterables) |
boolean |
QueryEngine.exists(QueryMetadata metadata,
java.util.Map<Expression<?>,java.lang.Iterable<?>> iterables)
Evaluate the given query return whether rows where matched
|
<T> java.util.List<T> |
DefaultQueryEngine.list(QueryMetadata metadata,
java.util.Map<Expression<?>,java.lang.Iterable<?>> iterables,
Expression<T> projection) |
<T> java.util.List<T> |
QueryEngine.list(QueryMetadata metadata,
java.util.Map<Expression<?>,java.lang.Iterable<?>> iterables,
Expression<T> projection)
Evaluate the given query and return the projection as a list
|
protected void |
CollQuerySerializer.visitOperation(java.lang.Class<?> type,
Operator operator,
java.util.List<? extends Expression<?>> args) |
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() |
@Nullable Expression<?> |
QueryMetadata.getProjection()
Get the projection
|
Expression<?> |
EmptyMetadata.getProjection() |
Expression<?> |
DefaultQueryMetadata.getProjection() |
Expression<?> |
JoinExpression.getTarget() |
Modifier and Type | Method and Description |
---|---|
java.util.List<Expression<?>> |
EmptyMetadata.getGroupBy() |
java.util.List<Expression<?>> |
DefaultQueryMetadata.getGroupBy() |
Modifier and Type | Method and Description |
---|---|
void |
QueryMetadata.addGroupBy(Expression<?> o)
Add the given group by expressions
|
void |
EmptyMetadata.addGroupBy(Expression<?> o) |
void |
DefaultQueryMetadata.addGroupBy(Expression<?> o) |
void |
QueryMetadata.addJoin(JoinType joinType,
Expression<?> expr)
Add the given query join
|
void |
EmptyMetadata.addJoin(JoinType joinType,
Expression<?> expr) |
void |
DefaultQueryMetadata.addJoin(JoinType joinType,
Expression<?> expr) |
<T> T |
Tuple.get(Expression<T> expr)
Get a tuple element by expression
|
Q |
Query.groupBy(Expression<?>... o)
Add grouping/aggregation expressions
|
FetchableQuery<Tuple,?> |
FetchableQuery.select(Expression<?>... exprs)
Change the projection of this query
|
<U> FetchableQuery<U,?> |
FetchableQuery.select(Expression<U> expr)
Change the projection of this query
|
void |
QueryMetadata.setProjection(Expression<?> o)
Set the projection
|
void |
EmptyMetadata.setProjection(Expression<?> o) |
void |
DefaultQueryMetadata.setProjection(Expression<?> o) |
Constructor and Description |
---|
JoinExpression(JoinType type,
Expression<?> target)
Create a new JoinExpression instance
|
JoinExpression(JoinType type,
Expression<?> target,
@Nullable Predicate condition,
java.util.Set<JoinFlag> flags)
Create a new JoinExpression instance
|
JoinFlag(Expression<?> flag)
Create a new instance using the given flag
|
JoinFlag(Expression<?> flag,
JoinFlag.Position position)
Create a new instance using the given flag and 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
|
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(java.lang.Class<A> cl,
Expression<? extends A> expr)
Create a new alias proxy of the given type for the given expression
|
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 |
MixinGroupExpression<E,F,R>
MixinGroupExpression provides nesting support for GroupExpression instances |
class |
QPair<K,V>
A pair of (Map) key and value
|
Modifier and Type | Field and Description |
---|---|
protected Expression<?>[] |
AbstractGroupByTransformer.expressions |
protected Expression<K> |
GroupByBuilder.key |
Modifier and Type | Method and Description |
---|---|
Expression<T> |
AbstractGroupExpression.getExpression() |
Expression<T> |
GroupExpression.getExpression()
Get the expression wrapped by this group definition
|
protected <V> Expression<V> |
GroupByBuilder.getLookup(Expression<V> expression) |
Modifier and Type | Method and Description |
---|---|
ResultTransformer<java.util.Map<K,Group>> |
GroupByBuilder.as(Expression<?>... expressions)
Get the results as a map
|
<V> ResultTransformer<java.util.Map<K,V>> |
GroupByBuilder.as(Expression<V> expression)
Get the results as a map
|
<RES extends java.util.Map<K,Group>> |
GroupByBuilder.as(java.util.function.Supplier<RES> mapFactory,
Expression<?>... expressions)
Get the results as a map
|
<V,RES extends java.util.Map<K,V>> |
GroupByBuilder.as(java.util.function.Supplier<RES> mapFactory,
Expression<V> expression)
Get the results as a map
|
static <E extends java.lang.Number> |
GroupBy.avg(Expression<E> expression)
Create a new aggregating avg expression, uses default MathContext.DECIMAL128 for average calculation
|
static <E extends java.lang.Number> |
GroupBy.avg(Expression<E> expression,
java.math.MathContext mathContext)
Create a new aggregating avg expression with a user-provided MathContext
|
<RES extends java.util.Collection<Group>> |
GroupByBuilder.collection(java.util.function.Supplier<RES> resultFactory,
Expression<?>... expressions)
Get the results as a collection.
|
<V,RES extends java.util.Collection<V>> |
GroupByBuilder.collection(java.util.function.Supplier<RES> resultFactory,
Expression<V> expression)
Get the results as a set
|
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,
java.lang.Class<?> valueType) |
boolean |
QPair.equals(Expression<?> keyExpr,
Expression<?> valueExpr) |
boolean |
QPair.equals(Expression<?> keyExpr,
Expression<?> valueExpr) |
<T> java.util.List<T> |
Group.getList(Expression<T> expr)
Returns a List of values in this group.
|
<T> java.util.List<T> |
GroupImpl.getList(Expression<T> expr) |
protected <V> Expression<V> |
GroupByBuilder.getLookup(Expression<V> expression) |
<K,V> java.util.Map<K,V> |
Group.getMap(Expression<K> key,
Expression<V> value)
Returns a Map of values in this group
|
<K,V> java.util.Map<K,V> |
Group.getMap(Expression<K> key,
Expression<V> value)
Returns a Map of values in this group
|
<K,V> java.util.Map<K,V> |
GroupImpl.getMap(Expression<K> key,
Expression<V> value) |
<K,V> java.util.Map<K,V> |
GroupImpl.getMap(Expression<K> key,
Expression<V> value) |
<T> T |
Group.getOne(Expression<T> expr)
Returns the value of the given single valued expression.
|
<T> T |
GroupImpl.getOne(Expression<T> expr) |
<T> java.util.Set<T> |
Group.getSet(Expression<T> expr)
Returns a Set of values in this group.
|
<T> java.util.Set<T> |
GroupImpl.getSet(Expression<T> expr) |
<K,V> java.util.SortedMap<K,V> |
Group.getSortedMap(Expression<K> key,
Expression<V> value)
Returns a SortedMap of values in this group
|
<K,V> java.util.SortedMap<K,V> |
Group.getSortedMap(Expression<K> key,
Expression<V> value)
Returns a SortedMap of values in this group
|
<K,V> java.util.SortedMap<K,V> |
GroupImpl.getSortedMap(Expression<K> key,
Expression<V> value) |
<K,V> java.util.SortedMap<K,V> |
GroupImpl.getSortedMap(Expression<K> key,
Expression<V> value) |
<T> java.util.SortedSet<T> |
Group.getSortedSet(Expression<T> expr)
Returns a SortedSet of values in this group.
|
<T> java.util.SortedSet<T> |
GroupImpl.getSortedSet(Expression<T> expr) |
static GroupByBuilder<java.util.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<java.util.List<Group>> |
GroupByBuilder.list(Expression<?>... expressions)
Get the results as a list
|
static <E> AbstractGroupExpression<E,java.util.List<E>> |
GroupBy.list(Expression<E> expression)
Create a new aggregating list expression
|
<V> ResultTransformer<java.util.List<V>> |
GroupByBuilder.list(Expression<V> expression)
Get the results as a list
|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,java.util.Map<K,V>> |
GroupBy.map(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,java.util.Map<K,V>> |
GroupBy.map(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,java.util.Map<K,U>> |
GroupBy.map(Expression<K> key,
GroupExpression<V,U> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,java.util.Map<T,V>> |
GroupBy.map(GroupExpression<K,T> key,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <E extends java.lang.Comparable<? super E>> |
GroupBy.max(Expression<E> expression)
Create a new aggregating max expression
|
static <E extends java.lang.Comparable<? super E>> |
GroupBy.min(Expression<E> expression)
Create a new aggregating min expression
|
static <E> AbstractGroupExpression<E,java.util.Set<E>> |
GroupBy.set(Expression<E> expression)
Create a new aggregating set expression using a backing LinkedHashSet
|
static <K extends java.lang.Comparable<? super K>,V> |
GroupBy.sortedMap(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression using a backing TreeMap
|
static <K extends java.lang.Comparable<? super K>,V> |
GroupBy.sortedMap(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression using a backing TreeMap
|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,java.util.SortedMap<K,V>> |
GroupBy.sortedMap(Expression<K> key,
Expression<V> value,
java.util.Comparator<? super K> comparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,java.util.SortedMap<K,V>> |
GroupBy.sortedMap(Expression<K> key,
Expression<V> value,
java.util.Comparator<? super K> comparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K extends java.lang.Comparable<? super K>,V,U> |
GroupBy.sortedMap(Expression<K> key,
GroupExpression<V,U> value)
Create a new aggregating map expression using a backing TreeMap
|
static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,java.util.SortedMap<K,U>> |
GroupBy.sortedMap(Expression<K> key,
GroupExpression<V,U> value,
java.util.Comparator<? super K> comparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K,V,T extends java.lang.Comparable<? super T>> |
GroupBy.sortedMap(GroupExpression<K,T> key,
Expression<V> value)
Create a new aggregating map expression using a backing TreeMap
|
static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,java.util.SortedMap<T,V>> |
GroupBy.sortedMap(GroupExpression<K,T> key,
Expression<V> value,
java.util.Comparator<? super T> comparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <E extends java.lang.Comparable<? super E>> |
GroupBy.sortedSet(Expression<E> expression)
Create a new aggregating set expression using a backing TreeSet
|
static <E> AbstractGroupExpression<E,java.util.SortedSet<E>> |
GroupBy.sortedSet(Expression<E> expression,
java.util.Comparator<? super E> comparator)
Create a new aggregating set expression using a backing TreeSet using the given comparator
|
static <E extends java.lang.Number> |
GroupBy.sum(Expression<E> expression)
Create a new aggregating sum expression
|
Constructor and Description |
---|
AbstractGroupByTransformer(Expression<K> key,
Expression<?>... expressions) |
AbstractGroupByTransformer(Expression<K> key,
Expression<?>... expressions) |
AbstractGroupExpression(java.lang.Class<? super R> type,
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) |
QPair(Expression<K> key,
Expression<V> value) |
QPair(Expression<K> key,
Expression<V> value) |
Modifier and Type | Method and Description |
---|---|
<V> ResultTransformer<com.google.common.collect.Multimap<K,V>> |
GuavaGroupByBuilder.asMultimap(Expression<V> expression)
Get the results as multi map
|
<V extends java.lang.Comparable<? super V>> |
GuavaGroupByBuilder.asSortedSetMultimap(Expression<V> expression)
Get the results as multi map
|
<V> ResultTransformer<com.google.common.collect.TreeMultimap<K,V>> |
GuavaGroupByBuilder.asSortedSetMultimap(Expression<V> expression,
java.util.Comparator<? super K> comparator,
java.util.Comparator<? super V> valueComparator)
Get the results as multi map
|
<C extends java.lang.Comparable<? super C>,V> |
GuavaGroupByBuilder.asSortedTable(Expression<C> column,
Expression<V> expression)
Get the results as sorted table
|
<C extends java.lang.Comparable<? super C>,V> |
GuavaGroupByBuilder.asSortedTable(Expression<C> column,
Expression<V> expression)
Get the results as sorted table
|
<C,V> ResultTransformer<com.google.common.collect.TreeBasedTable<K,C,V>> |
GuavaGroupByBuilder.asSortedTable(Expression<C> column,
Expression<V> expression,
java.util.Comparator<? super K> rowComparator,
java.util.Comparator<? super C> columnComparator)
Get the results as sorted table
|
<C,V> ResultTransformer<com.google.common.collect.TreeBasedTable<K,C,V>> |
GuavaGroupByBuilder.asSortedTable(Expression<C> column,
Expression<V> expression,
java.util.Comparator<? super K> rowComparator,
java.util.Comparator<? super C> columnComparator)
Get the results as sorted table
|
<C,V> ResultTransformer<com.google.common.collect.Table<K,C,V>> |
GuavaGroupByBuilder.asTable(Expression<C> column,
Expression<V> expression)
Get the results as sorted table
|
<C,V> ResultTransformer<com.google.common.collect.Table<K,C,V>> |
GuavaGroupByBuilder.asTable(Expression<C> column,
Expression<V> expression)
Get the results as sorted table
|
static <K> GuavaGroupByBuilder<K> |
GuavaGroupBy.groupBy(Expression<K> key)
Create a new GroupByBuilder for the given key expression
|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,com.google.common.collect.Multimap<K,V>> |
GuavaGroupBy.multimap(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,com.google.common.collect.Multimap<K,V>> |
GuavaGroupBy.multimap(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,com.google.common.collect.Multimap<K,U>> |
GuavaGroupBy.multimap(Expression<K> key,
GroupExpression<V,U> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,com.google.common.collect.Multimap<T,V>> |
GuavaGroupBy.multimap(GroupExpression<K,T> key,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <K extends java.lang.Comparable<? super K>,V extends java.lang.Comparable<? super V>> |
GuavaGroupBy.sortedSetMultimap(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression using a backing TreeMap
|
static <K extends java.lang.Comparable<? super K>,V extends java.lang.Comparable<? super V>> |
GuavaGroupBy.sortedSetMultimap(Expression<K> key,
Expression<V> value)
Create a new aggregating map expression using a backing TreeMap
|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,com.google.common.collect.SortedSetMultimap<K,V>> |
GuavaGroupBy.sortedSetMultimap(Expression<K> key,
Expression<V> value,
java.util.Comparator<? super K> keyComparator,
java.util.Comparator<? super V> valueComparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,com.google.common.collect.SortedSetMultimap<K,V>> |
GuavaGroupBy.sortedSetMultimap(Expression<K> key,
Expression<V> value,
java.util.Comparator<? super K> keyComparator,
java.util.Comparator<? super V> valueComparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K extends java.lang.Comparable<? super K>,V,U> |
GuavaGroupBy.sortedSetMultimap(Expression<K> key,
GroupExpression<V,U> value)
Create a new aggregating map expression using a backing TreeMap
|
static <K,V,U> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,com.google.common.collect.SortedSetMultimap<K,U>> |
GuavaGroupBy.sortedSetMultimap(Expression<K> key,
GroupExpression<V,U> value,
java.util.Comparator<? super K> keyComparator,
java.util.Comparator<? super U> valueComparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <K,V,T extends java.lang.Comparable<? super T>> |
GuavaGroupBy.sortedSetMultimap(GroupExpression<K,T> key,
Expression<V> value)
Create a new aggregating map expression using a backing TreeMap
|
static <K,V,T> AbstractGroupExpression<com.mysema.commons.lang.Pair<K,V>,com.google.common.collect.SortedSetMultimap<T,V>> |
GuavaGroupBy.sortedSetMultimap(GroupExpression<K,T> key,
Expression<V> value,
java.util.Comparator<? super T> comparator,
java.util.Comparator<? super V> valueComparator)
Create a new aggregating map expression using a backing TreeMap using the given comparator
|
static <R,C,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<R,C,V>> |
GuavaGroupBy.sortedTable(Expression<R> row,
Expression<C> column,
Expression<V> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<R,C,V>> |
GuavaGroupBy.sortedTable(Expression<R> row,
Expression<C> column,
Expression<V> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<R,C,V>> |
GuavaGroupBy.sortedTable(Expression<R> row,
Expression<C> column,
Expression<V> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<R,C,W>> |
GuavaGroupBy.sortedTable(Expression<R> row,
Expression<C> column,
GroupExpression<V,W> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<R,C,W>> |
GuavaGroupBy.sortedTable(Expression<R> row,
Expression<C> column,
GroupExpression<V,W> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<R,W,V>> |
GuavaGroupBy.sortedTable(Expression<R> row,
GroupExpression<C,W> column,
Expression<V> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super W> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<R,W,V>> |
GuavaGroupBy.sortedTable(Expression<R> row,
GroupExpression<C,W> column,
Expression<V> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super W> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.sortedTable(Expression<R> row,
GroupExpression<C,X> column,
GroupExpression<V,W> value,
java.util.Comparator<? super R> rowComparator,
java.util.Comparator<? super X> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<W,C,V>> |
GuavaGroupBy.sortedTable(GroupExpression<R,W> row,
Expression<C> column,
Expression<V> value,
java.util.Comparator<? super W> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.TreeBasedTable<W,C,V>> |
GuavaGroupBy.sortedTable(GroupExpression<R,W> row,
Expression<C> column,
Expression<V> value,
java.util.Comparator<? super W> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.sortedTable(GroupExpression<R,W> row,
GroupExpression<C,X> column,
Expression<V> value,
java.util.Comparator<? super W> rowComparator,
java.util.Comparator<? super X> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.sortedTable(GroupExpression<R,X> row,
Expression<C> column,
GroupExpression<V,W> value,
java.util.Comparator<? super X> rowComparator,
java.util.Comparator<? super C> columnComparator)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<R,C,V>> |
GuavaGroupBy.table(Expression<R> row,
Expression<C> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<R,C,V>> |
GuavaGroupBy.table(Expression<R> row,
Expression<C> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<R,C,V>> |
GuavaGroupBy.table(Expression<R> row,
Expression<C> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<R,C,W>> |
GuavaGroupBy.table(Expression<R> row,
Expression<C> column,
GroupExpression<V,W> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<R,C,W>> |
GuavaGroupBy.table(Expression<R> row,
Expression<C> column,
GroupExpression<V,W> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<R,W,V>> |
GuavaGroupBy.table(Expression<R> row,
GroupExpression<C,W> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<R,W,V>> |
GuavaGroupBy.table(Expression<R> row,
GroupExpression<C,W> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.table(Expression<R> row,
GroupExpression<C,X> column,
GroupExpression<V,W> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<W,C,V>> |
GuavaGroupBy.table(GroupExpression<R,W> row,
Expression<C> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W> AbstractGroupExpression<com.mysema.commons.lang.Pair<com.mysema.commons.lang.Pair<R,C>,V>,com.google.common.collect.Table<W,C,V>> |
GuavaGroupBy.table(GroupExpression<R,W> row,
Expression<C> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.table(GroupExpression<R,W> row,
GroupExpression<C,X> column,
Expression<V> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
static <R,C,V,W,X> |
GuavaGroupBy.table(GroupExpression<R,X> row,
Expression<C> column,
GroupExpression<V,W> value)
Create a new aggregating map expression using a backing LinkedHashMap
|
Constructor and Description |
---|
GuavaGroupByBuilder(Expression<K> key)
Create a new GroupByBuilder for the given key expression
|
Modifier and Type | Interface and Description |
---|---|
interface |
ExtendedSubQuery<T>
ExtendedSubQuery extends the SubQueryExpression interface to provide fluent
expression creation functionality |
Modifier and Type | Class and Description |
---|---|
class |
ConstantHidingExpression<T>
ConstantHidingExpression removes constants from the argument list and injects them back into the result chain |
class |
EnumConversion<T>
EnumConversion ensures that the results of an enum projection conform to the type of the
projection expression |
class |
FetchableSubQueryBase<T,Q extends FetchableSubQueryBase<T,Q>>
FetchableSubQueryBase extends FetchableQueryBase to provide fluent Expression creation functionality |
class |
NumberConversion<T>
NumberConversion ensures that the results of a numeric projection conform to the type of the
projection expression |
class |
NumberConversions<T>
NumberConversions ensures that the results of a projection involving numeric expressions
conform to the types of the numeric expressions |
Modifier and Type | Method and Description |
---|---|
<RT> Expression<RT> |
QueryMixin.convert(Expression<RT> expr,
QueryMixin.Role role) |
protected <D> Expression<D> |
QueryMixin.createAlias(Expression<?> expr,
Path<D> alias) |
Expression<?> |
QueryMixin.setProjection(Expression<?>... o) |
<E> Expression<E> |
QueryMixin.setProjection(Expression<E> e) |
Expression<?> |
ReplaceVisitor.visit(Constant<?> expr,
C context) |
Expression<?> |
CollectionAnyVisitor.visit(Constant<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(FactoryExpression<?> expr,
C context) |
Expression<?> |
CollectionAnyVisitor.visit(FactoryExpression<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(Operation<?> expr,
C context) |
Expression<?> |
CollectionAnyVisitor.visit(Operation<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(ParamExpression<?> expr,
C context) |
Expression<?> |
CollectionAnyVisitor.visit(ParamExpression<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(Path<?> expr,
C context) |
Expression<?> |
CollectionAnyVisitor.visit(Path<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(SubQueryExpression<?> expr,
C context) |
Expression<?> |
CollectionAnyVisitor.visit(SubQueryExpression<?> expr,
Context context) |
Expression<?> |
ReplaceVisitor.visit(TemplateExpression<?> expr,
C context) |
Expression<?> |
CollectionAnyVisitor.visit(TemplateExpression<?> expr,
Context context) |
Modifier and Type | Method and Description |
---|---|
java.util.List<Expression<?>> |
EnumConversion.getArgs() |
java.util.List<Expression<?>> |
ConstantHidingExpression.getArgs() |
java.util.List<Expression<?>> |
NumberConversions.getArgs() |
java.util.List<Expression<?>> |
NumberConversion.getArgs() |
Modifier and Type | Method and Description |
---|---|
T |
QueryMixin.addJoin(JoinType joinType,
Expression<?> target) |
void |
OrderedQueryMetadata.addJoin(JoinType joinType,
Expression<?> expr) |
BooleanExpression |
ExtendedSubQuery.contains(Expression<? extends T> right)
Create a
right in this expression |
BooleanExpression |
FetchableSubQueryBase.contains(Expression<? extends T> right) |
<RT> Expression<RT> |
QueryMixin.convert(Expression<RT> expr,
QueryMixin.Role role) |
protected <D> Expression<D> |
QueryMixin.createAlias(Expression<?> expr,
Path<D> alias) |
BooleanExpression |
ExtendedSubQuery.eq(Expression<? extends T> expr)
Create a
this == right expression |
BooleanExpression |
FetchableSubQueryBase.eq(Expression<? extends T> expr) |
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) |
BooleanExpression |
ExtendedSubQuery.goe(Expression<? extends T> expr)
Create a
this >= right expression |
BooleanExpression |
FetchableSubQueryBase.goe(Expression<? extends T> expr) |
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
|
BooleanExpression |
ExtendedSubQuery.gt(Expression<? extends T> expr)
Create a
this > right expression |
BooleanExpression |
FetchableSubQueryBase.gt(Expression<? extends T> expr) |
S |
SerializerBase.handle(Expression<?> expr) |
S |
SerializerBase.handle(java.lang.String sep,
Expression<?>[] expressions) |
<P> T |
QueryMixin.innerJoin(Expression<P> target) |
<P> T |
QueryMixin.innerJoin(Expression<P> target,
Path<P> alias) |
<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) |
BooleanExpression |
ExtendedSubQuery.loe(Expression<? extends T> expr)
Create a
this <= right expression |
BooleanExpression |
FetchableSubQueryBase.loe(Expression<? extends T> expr) |
BooleanExpression |
ExtendedSubQuery.lt(Expression<? extends T> expr)
Create a
this < right expression |
BooleanExpression |
FetchableSubQueryBase.lt(Expression<? extends T> expr) |
BooleanExpression |
ExtendedSubQuery.ne(Expression<? extends T> expr)
Create a
this != right expression |
BooleanExpression |
FetchableSubQueryBase.ne(Expression<? extends T> expr) |
<P> T |
QueryMixin.rightJoin(Expression<P> target) |
<P> T |
QueryMixin.rightJoin(Expression<P> target,
Path<P> alias) |
Expression<?> |
QueryMixin.setProjection(Expression<?>... o) |
<E> Expression<E> |
QueryMixin.setProjection(Expression<E> e) |
Modifier and Type | Method and Description |
---|---|
S |
SerializerBase.handle(java.lang.String sep,
java.util.List<? extends Expression<?>> expressions) |
protected void |
SerializerBase.visitOperation(java.lang.Class<?> type,
Operator operator,
java.util.List<? extends Expression<?>> args) |
Constructor and Description |
---|
EnumConversion(Expression<T> expr) |
NumberConversion(Expression<T> expr) |
Modifier and Type | Interface and Description |
---|---|
interface |
CollectionExpression<T extends java.util.Collection<E>,E>
CollectionExpression represents java.util.Collection typed expressions |
interface |
Constant<T>
Constant represents a general constant expression. |
interface |
EntityPath<T>
EntityPath is the common interface for entity path expressions |
interface |
FactoryExpression<T>
FactoryExpression represents factory expressions such as JavaBean or
Constructor projections |
interface |
MapExpression<K,V>
MapExpression represents java.util.Map typed expressions |
interface |
Operation<T>
Operation represents an operation with operator and arguments |
interface |
ParameterizedExpression<T>
ParameterizedExpression 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 FactoryExpressionBase 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>
FactoryExpressionAdapter provides an adapter implementation of the FactoryExpression interface |
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 |
ParameterizedPathImpl<T>
ParameterizedPathImpl represents Path instances with a parameterized generic type |
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)
Create a
all col expression |
static <T> Expression<T> |
ExpressionUtils.all(SubQueryExpression<? extends T> col)
Create a
all col expression |
static <T> Expression<T> |
ExpressionUtils.any(CollectionExpression<?,? super T> col)
Create a
any col expression |
static <T> Expression<T> |
ExpressionUtils.any(SubQueryExpression<? extends T> col)
Create a
any col expression |
static <D> Expression<D> |
ExpressionUtils.as(Expression<D> source,
Path<D> alias)
Create an alias expression with the given source and alias
|
static <D> Expression<D> |
ExpressionUtils.as(Expression<D> source,
java.lang.String alias)
Create an alias expression 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(java.lang.String alias)
Create an alias for the expression
|
Expression<T> |
QBean.as(java.lang.String alias)
Create an alias for the expression
|
static Expression<java.lang.Long> |
ExpressionUtils.count(Expression<?> source)
Create a
count(source) expression |
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<java.lang.String> |
ExpressionUtils.likeToRegex(Expression<java.lang.String> expr)
Convert the given like pattern to a regex pattern
|
static Expression<java.lang.String> |
ExpressionUtils.likeToRegex(Expression<java.lang.String> expr,
boolean matchStartAndEnd)
Convert the given like pattern to a regex pattern
|
static <T> Expression<T> |
ExpressionUtils.list(java.lang.Class<T> clazz,
Expression<?>... exprs)
Create a list expression for the given arguments
|
static <T> Expression<T> |
ExpressionUtils.list(java.lang.Class<T> clazz,
java.util.List<? extends Expression<?>> exprs)
Create a list expression for the given arguments
|
static Expression<?> |
ExpressionUtils.orderBy(java.util.List<OrderSpecifier<?>> args)
Create an expression out of the given order specifiers
|
static Expression<java.lang.String> |
ExpressionUtils.regexToLike(Expression<java.lang.String> expr)
Convert the given expression from regex form to like
|
static Expression<?> |
ExpressionUtils.toExpression(java.lang.Object o)
Converts the given object to an Expression
|
static Expression<java.lang.String> |
ExpressionUtils.toLower(Expression<java.lang.String> stringExpression)
Converts the given expression to lower(expression)
|
Modifier and Type | Method and Description |
---|---|
static java.util.List<Expression<?>> |
ExpressionUtils.distinctList(Expression<?>... args)
Create a distinct list of the given args
|
static java.util.List<Expression<?>> |
ExpressionUtils.distinctList(Expression<?>[]... args)
Create a distinct list of the concatenated array contents
|
java.util.List<Expression<?>> |
QBean.getArgs() |
java.util.List<Expression<?>> |
FactoryExpressionUtils.FactoryExpressionAdapter.getArgs() |
java.util.List<Expression<?>> |
FactoryExpression.getArgs()
Get the invocation arguments
|
java.util.List<Expression<?>> |
MappingProjection.getArgs() |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(Constant<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(FactoryExpression<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(Operation<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(ParamExpression<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(Path<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(SubQueryExpression<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(TemplateExpression<?> expr,
java.util.Set<Expression<?>> known) |
Modifier and Type | Method and Description |
---|---|
static <T> com.querydsl.core.types.AppendingFactoryExpression<T> |
Projections.appending(Expression<T> base,
Expression<?>... rest)
Create an appending factory expression which serializes all the arguments but the uses
the base value as the return value
|
static <T> com.querydsl.core.types.AppendingFactoryExpression<T> |
Projections.appending(Expression<T> base,
Expression<?>... rest)
Create an appending factory expression which serializes all the arguments but the uses
the base value as the return value
|
static <T> ArrayConstructorExpression<T> |
Projections.array(java.lang.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 with the given source and alias
|
static <D> Expression<D> |
ExpressionUtils.as(Expression<D> source,
java.lang.String alias)
Create an alias expression with the given source and alias
|
static <T> QBean<T> |
Projections.bean(java.lang.Class<? extends T> type,
Expression<?>... exprs)
Create a Bean populating projection for the given type and expressions
|
static <T> QBean<T> |
Projections.bean(Path<? extends T> type,
Expression<?>... exprs)
Create a Bean populating projection for the given type and expressions
|
static <T> ConstructorExpression<T> |
Projections.constructor(java.lang.Class<? extends T> type,
java.lang.Class<?>[] paramTypes,
Expression<?>... exprs)
Create a constructor invocation projection for given type, parameter types and expressions
|
static <T> ConstructorExpression<T> |
Projections.constructor(java.lang.Class<? extends T> type,
Expression<?>... exprs)
Create a constructor invocation projection for the given type and expressions
|
static Expression<java.lang.Long> |
ExpressionUtils.count(Expression<?> source)
Create a
count(source) expression |
static java.util.List<Expression<?>> |
ExpressionUtils.distinctList(Expression<?>... args)
Create a distinct list of the given args
|
static java.util.List<Expression<?>> |
ExpressionUtils.distinctList(Expression<?>[]... args)
Create a distinct list of the concatenated array contents
|
static <D> Predicate |
ExpressionUtils.eq(Expression<D> left,
Expression<? extends D> right)
Create a
left == right expression |
static <D> Predicate |
ExpressionUtils.eq(Expression<D> left,
Expression<? extends D> right)
Create a
left == right expression |
static <D> Predicate |
ExpressionUtils.eqConst(Expression<D> left,
D constant)
Create a
left == constant expression |
static <T> Expression<T> |
ExpressionUtils.extract(Expression<T> expr)
Get the potentially wrapped expression
|
static <T> QBean<T> |
Projections.fields(java.lang.Class<? extends 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<? extends T> type,
Expression<?>... exprs)
Create a field access based Bean populating projection for the given type and expressions
|
static PathMetadata |
PathMetadataFactory.forArrayAccess(Path<?> parent,
Expression<java.lang.Integer> index)
Create a new PathMetadata instance for indexed array access
|
static PathMetadata |
PathMetadataFactory.forListAccess(Path<?> parent,
Expression<java.lang.Integer> index)
Create a new PathMetadata instance for indexed list access
|
static <KT> PathMetadata |
PathMetadataFactory.forMapAccess(Path<?> parent,
Expression<KT> key)
Create a new PathMetadata instance for key based map access
|
static <D> Predicate |
ExpressionUtils.in(Expression<D> left,
java.util.Collection<? extends D> right)
Create a
left in right expression |
static <D> Predicate |
ExpressionUtils.in(Expression<D> left,
CollectionExpression<?,? extends D> right)
Create a
left in right expression |
static <D> Predicate |
ExpressionUtils.in(Expression<D> left,
SubQueryExpression<? extends D> right)
Create a
left in right expression |
static <D> Predicate |
ExpressionUtils.inAny(Expression<D> left,
java.lang.Iterable<? extends java.util.Collection<? extends D>> lists)
Create a
left in right or... expression for each list |
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<java.lang.String> |
ExpressionUtils.likeToRegex(Expression<java.lang.String> expr)
Convert the given like pattern to a regex pattern
|
static Expression<java.lang.String> |
ExpressionUtils.likeToRegex(Expression<java.lang.String> expr,
boolean matchStartAndEnd)
Convert the given like pattern to a regex pattern
|
static <T> Expression<T> |
ExpressionUtils.list(java.lang.Class<T> clazz,
Expression<?>... exprs)
Create a list expression for the given arguments
|
static QList |
Projections.list(Expression<?>... args)
Create a new List typed projection for the given expressions
|
static QList |
Projections.list(Expression<?>[]... args)
Create a new List typed projection for the given expressions
|
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 != right expression |
static <D> Predicate |
ExpressionUtils.ne(Expression<D> left,
Expression<? super D> right)
Create a
left != right expression |
static <D> Predicate |
ExpressionUtils.neConst(Expression<D> left,
D constant)
Create a
left != constant expression |
static <D> Predicate |
ExpressionUtils.notIn(Expression<D> left,
java.util.Collection<? extends D> right)
Create a
left not in right expression |
static <D> Predicate |
ExpressionUtils.notIn(Expression<D> left,
CollectionExpression<?,? extends D> right)
Create a
left not in right expression |
static <D> Predicate |
ExpressionUtils.notIn(Expression<D> left,
SubQueryExpression<? extends D> right)
Create a
left not in right expression |
static <D> Predicate |
ExpressionUtils.notInAny(Expression<D> left,
java.lang.Iterable<? extends java.util.Collection<? extends D>> lists)
Create a
left not in right and... expression for each list |
static <T> Operation<T> |
ExpressionUtils.operation(java.lang.Class<? extends T> type,
Operator operator,
Expression<?>... args)
Create a new Operation expression
|
static PredicateOperation |
ExpressionUtils.predicate(Operator operator,
Expression<?>... args)
Create a new Operation expression
|
protected void |
QBean.propertyNotFound(Expression<?> expr,
java.lang.String property) |
static Expression<java.lang.String> |
ExpressionUtils.regexToLike(Expression<java.lang.String> expr)
Convert the given expression from regex form to like
|
static Expression<java.lang.String> |
ExpressionUtils.toLower(Expression<java.lang.String> stringExpression)
Converts the given expression to lower(expression)
|
static QTuple |
Projections.tuple(Expression<?>... exprs)
Create a Tuple typed projection for the given expressions
|
static QTuple |
Projections.tuple(Expression<?>[]... exprs)
Create a Tuple typed projection for the given expressions
|
protected void |
QBean.typeMismatch(java.lang.Class<?> type,
Expression<?> expr) |
Modifier and Type | Method and Description |
---|---|
static <T> QBean<T> |
Projections.bean(java.lang.Class<? extends T> type,
java.util.Map<java.lang.String,? extends Expression<?>> bindings)
Create a Bean populating projection for the given type and bindings
|
static <T> QBean<T> |
Projections.bean(Path<? extends T> type,
java.util.Map<java.lang.String,? extends Expression<?>> bindings)
Create a Bean populating projection for the given type and bindings
|
static <T> ConstructorExpression<T> |
Projections.constructor(java.lang.Class<? extends T> type,
java.lang.Class<?>[] paramTypes,
java.util.List<Expression<?>> exprs)
Create a constructor invocation projection for given type, parameter types and expressions
|
static <T> QBean<T> |
Projections.fields(java.lang.Class<? extends T> type,
java.util.Map<java.lang.String,? extends Expression<?>> bindings)
Create a field access based Bean populating projection for the given type and bindings
|
static <T> QBean<T> |
Projections.fields(Path<? extends T> type,
java.util.Map<java.lang.String,? extends Expression<?>> bindings)
Create a field access based Bean populating projection for the given type and bindings
|
static <T> Expression<T> |
ExpressionUtils.list(java.lang.Class<T> clazz,
java.util.List<? extends Expression<?>> exprs)
Create a list expression for the given arguments
|
static QList |
Projections.list(java.util.List<Expression<?>> args)
Create a new List typed projection for the given expressions
|
static <T> Operation<T> |
ExpressionUtils.operation(java.lang.Class<? extends T> type,
Operator operator,
java.util.List<Expression<?>> args)
Create a new Operation expression
|
static PredicateOperation |
ExpressionUtils.predicate(Operator operator,
java.util.List<Expression<?>> args)
Create a new Operation expression
|
static QTuple |
Projections.tuple(java.util.List<Expression<?>> exprs)
Create a Tuple typed projection for the given expressions
|
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(Constant<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(FactoryExpression<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(Operation<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(ParamExpression<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(Path<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(SubQueryExpression<?> expr,
java.util.Set<Expression<?>> known) |
java.util.Set<Expression<?>> |
ValidatingVisitor.visit(TemplateExpression<?> expr,
java.util.Set<Expression<?>> known) |
static <T> FactoryExpression<T> |
FactoryExpressionUtils.wrap(FactoryExpression<T> expr,
java.util.List<Expression<?>> conversions) |
static FactoryExpression<?> |
FactoryExpressionUtils.wrap(java.util.List<? extends Expression<?>> projection) |
Constructor and Description |
---|
ArrayConstructorExpression(java.lang.Class<T[]> type,
Expression<T>... args) |
ArrayConstructorExpression(Expression<?>... args) |
ConstructorExpression(java.lang.Class<? extends T> type,
java.lang.Class<?>[] paramTypes,
Expression<?>... args) |
ConstructorExpression(java.lang.Class<? extends T> type,
Expression<?>... args) |
MappingProjection(java.lang.Class<? super T> type,
Expression<?>... args)
Create a new MappingProjection instance
|
MappingProjection(java.lang.Class<? super T> type,
Expression<?>[]... args)
Create a new MappingProjection instance
|
OperationImpl(java.lang.Class<? extends T> type,
Operator operator,
Expression<?>... args) |
OrderSpecifier(Order order,
Expression<T> target) |
OrderSpecifier(Order order,
Expression<T> target,
OrderSpecifier.NullHandling nullhandling) |
QBean(java.lang.Class<? extends T> type,
boolean fieldAccess,
Expression<?>... args)
Create a new QBean instance
|
QBean(java.lang.Class<? extends 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(java.lang.Class<? extends T> type,
java.lang.Class<?>[] paramTypes,
java.util.List<Expression<?>> args) |
OperationImpl(java.lang.Class<? extends T> type,
Operator operator,
java.util.List<Expression<?>> args) |
PredicateOperation(Operator operator,
java.util.List<Expression<?>> args) |
QBean(java.lang.Class<? extends T> type,
boolean fieldAccess,
java.util.Map<java.lang.String,? extends Expression<?>> bindings)
Create a new QBean instance
|
QBean(java.lang.Class<? extends T> type,
java.util.Map<java.lang.String,? extends Expression<?>> bindings)
Create a new QBean instance
|
QList(java.util.List<Expression<?>> args)
Create a new QList instance
|
QMap(java.util.List<Expression<?>> args)
Create a new QMap instance
|
QTuple(java.util.List<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>>
Intermediate step
|
class |
CaseForEqBuilder.CaseWhen<T,Q extends Expression<T>>
Intermediate step
|
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 java.util.List typed expressions |
Modifier and Type | Class and Description |
---|---|
class |
ArrayPath<A,E>
ArrayPath represents an array typed path |
class |
BeanPath<T>
BeanPath represents bean paths |
class |
BooleanExpression
BooleanExpression represents Boolean expressions |
class |
BooleanOperation
BooleanOperation represents boolean operations |
class |
BooleanPath
BooleanPath represents boolean path expressions |
class |
BooleanTemplate
BooleanTemplate is a custom boolean expression |
class |
Coalesce<T extends java.lang.Comparable>
Coalesce defines a coalesce function invocation. |
class |
CollectionExpressionBase<T extends java.util.Collection<E>,E>
CollectionExpressionBase is an abstract base class for CollectionExpression implementations |
class |
CollectionOperation<E>
CollectionOperation is a collection typed operation |
class |
CollectionPath<E,Q extends SimpleExpression<? super E>>
CollectionPath represents collection paths |
class |
CollectionPathBase<C extends java.util.Collection<E>,E,Q extends SimpleExpression<? super E>>
CollectionPath is a base class for collection typed paths |
class |
ComparableEntityPath<T extends java.lang.Comparable>
ComparableEntityPath extends the ComparablePath class to implement the EntityPath interface |
class |
ComparableExpression<T extends java.lang.Comparable>
ComparableExpression extends ComparableExpressionBase to provide comparison methods. |
class |
ComparableExpressionBase<T extends java.lang.Comparable>
ComparableExpressionBase represents comparable expressions |
class |
ComparableOperation<T extends java.lang.Comparable<?>>
ComparableOperation represents Comparable operations |
class |
ComparablePath<T extends java.lang.Comparable>
ComparablePath represents comparable paths |
class |
ComparableTemplate<T extends java.lang.Comparable<?>>
ComparableTemplate defines custom comparable expressions |
class |
DateExpression<T extends java.lang.Comparable>
DateExpression represents Date expressions
The date representation is compatible with the Gregorian calendar. |
class |
DateOperation<T extends java.lang.Comparable<?>>
DateOperation represents Date operations |
class |
DatePath<T extends java.lang.Comparable>
DatePath presents Date paths |
class |
DateTemplate<T extends java.lang.Comparable<?>>
DateTemplate defines custom date expressions |
class |
DateTimeExpression<T extends java.lang.Comparable>
DateTimeExpression represents Date / Time expressions
The date representation is compatible with the Gregorian calendar. |
class |
DateTimeOperation<T extends java.lang.Comparable<?>>
DateTimeOperation represents DateTime operations |
class |
DateTimePath<T extends java.lang.Comparable>
DateTimePath presents DateTime typed paths |
class |
DateTimeTemplate<T extends java.lang.Comparable<?>>
DateTimeTemplate defines custom dateTime expressions |
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 |
DslPath<T>
DslPath represents simple paths |
class |
DslTemplate<T>
DslTemplate defines custom simple expressions |
class |
EntityPathBase<T>
EntityPathBase provides a base class for EntityPath implementations |
class |
EnumExpression<T extends java.lang.Enum<T>>
EnumExpression represents Enum typed expressions |
class |
EnumOperation<T extends java.lang.Enum<T>>
EnumOperation represents enum operations |
class |
EnumPath<T extends java.lang.Enum<T>>
EnumPath represents enum paths |
class |
EnumTemplate<T extends java.lang.Enum<T>>
EnumTemplate defines custom enum expressions |
class |
ListPath<E,Q extends SimpleExpression<? super E>>
ListPath represents list paths |
class |
LiteralExpression<T extends java.lang.Comparable>
LiteralExpression represents literal expressions |
class |
MapExpressionBase<K,V,Q extends SimpleExpression<? super V>>
MapExpressionBase is an abstract base class for MapExpression implementations |
class |
MapPath<K,V,E extends SimpleExpression<? super V>>
MapPath represents map paths |
class |
NumberExpression<T extends java.lang.Number & java.lang.Comparable<?>>
NumberExpression represents a numeric expression |
class |
NumberOperation<T extends java.lang.Number & java.lang.Comparable<?>>
NumberOperation represents numeric operations |
class |
NumberPath<T extends java.lang.Number & java.lang.Comparable<?>>
NumberPath represents numeric paths |
class |
NumberTemplate<T extends java.lang.Number & java.lang.Comparable<?>>
NumberTemplate defines custom numeric expressions |
class |
Param<T>
Param defines a parameter in a query with an optional name |
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 |
SimpleExpression<T>
SimpleExpression is the base class for Expression implementations. |
class |
SimpleOperation<T>
SimpleOperation represents a simple operation expression |
class |
SimplePath<T>
SimplePath represents simple paths |
class |
SimpleTemplate<T>
SimpleTemplate defines custom simple expressions |
class |
StringExpression
StringExpression represents String expressions |
class |
StringOperation
StringOperation represents a String typed operation |
class |
StringPath
StringPath represents String typed paths |
class |
StringTemplate
StringTemplate defines custom String expressions |
class |
TemporalExpression<T extends java.lang.Comparable>
TemporalExpression is a supertype for Date/Time related types |
class |
TimeExpression<T extends java.lang.Comparable>
TimeExpression represents Time expressions |
class |
TimeOperation<T extends java.lang.Comparable<?>>
TimeOperation represents Time operations |
class |
TimePath<T extends java.lang.Comparable>
TimePath represented Time paths |
class |
TimeTemplate<T extends java.lang.Comparable<?>>
TimeTemplate defines custom time expressions |
Modifier and Type | Field and Description |
---|---|
static Expression<java.lang.Object[]> |
Wildcard.all
Wildcard expression (*) for all columns
|
protected Expression<T> |
DslExpression.mixin |
Modifier and Type | Method and Description |
---|---|
static <T> Expression<T> |
Expressions.constant(T value)
Create a Constant expression for the given value
|
Expression<?> |
EnumOperation.getArg(int index) |
Expression<?> |
StringOperation.getArg(int index) |
Expression<?> |
DateOperation.getArg(int index) |
Expression<?> |
DateTimeOperation.getArg(int index) |
Expression<?> |
TimeOperation.getArg(int index) |
Expression<?> |
ComparableOperation.getArg(int index) |
Expression<?> |
NumberOperation.getArg(int index) |
Expression<?> |
BooleanOperation.getArg(int index) |
Expression<?> |
SimpleOperation.getArg(int index) |
Expression<?> |
DslOperation.getArg(int index) |
static <T> Expression<T> |
Expressions.list(java.lang.Class<T> clazz,
Expression<?>... exprs)
Combine the given expressions into a list expression
|
static Expression<Tuple> |
Expressions.list(Expression<?>... exprs)
Combine the given expressions into a list expression
|
static <T> Expression<T> |
Expressions.set(java.lang.Class<T> clazz,
Expression<?>... exprs)
Combine the given expressions into a set expression
|
static Expression<Tuple> |
Expressions.set(Expression<?>... exprs)
Combine the given expressions into a set expression
|
Modifier and Type | Method and Description |
---|---|
java.util.List<Expression<?>> |
EnumOperation.getArgs() |
java.util.List<Expression<?>> |
StringOperation.getArgs() |
java.util.List<Expression<?>> |
DateOperation.getArgs() |
java.util.List<Expression<?>> |
DateTimeOperation.getArgs() |
java.util.List<Expression<?>> |
TimeOperation.getArgs() |
java.util.List<Expression<?>> |
ComparableOperation.getArgs() |
java.util.List<Expression<?>> |
NumberOperation.getArgs() |
java.util.List<Expression<?>> |
BooleanOperation.getArgs() |
java.util.List<Expression<?>> |
SimpleOperation.getArgs() |
java.util.List<Expression<?>> |
DslOperation.getArgs() |
<T> CaseForEqBuilder.Cases<T,Expression<T>> |
CaseForEqBuilder.then(Expression<T> expr) |
<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 java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.acos(Expression<A> num)
Create a
acos(num) expression |
<N extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.add(Expression<N> right)
Create a
this + right expression |
Coalesce<T> |
Coalesce.add(Expression<T> expr) |
BooleanExpression |
TemporalExpression.after(Expression<T> right)
Create a
this > right expression |
StringExpression |
StringExpression.append(Expression<java.lang.String> str)
Create a
concat(this, str) expression |
static <D> SimpleExpression<D> |
Expressions.as(Expression<D> source,
Path<D> alias)
Create a
source as alias expression |
static <D> SimpleExpression<D> |
Expressions.as(Expression<D> source,
java.lang.String alias)
Create a
source as alias expression |
static BooleanExpression |
Expressions.asBoolean(Expression<java.lang.Boolean> expr)
Create a new BooleanExpression
|
static <T extends java.lang.Comparable<?>> |
Expressions.asComparable(Expression<T> expr)
Create a new ComparableExpression
|
static <T extends java.lang.Comparable<?>> |
Expressions.asDate(Expression<T> expr)
Create a new DateExpression
|
static <T extends java.lang.Comparable<?>> |
Expressions.asDateTime(Expression<T> expr)
Create a new DateTimeExpression
|
static <T extends java.lang.Enum<T>> |
Expressions.asEnum(Expression<T> expr)
Create a new EnumExpression
|
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.asin(Expression<A> num)
Create a
asin(num) expression |
static <T extends java.lang.Number & java.lang.Comparable<?>> |
Expressions.asNumber(Expression<T> expr)
Create a new NumberExpression
|
static <T> SimpleExpression<T> |
Expressions.asSimple(Expression<T> expr)
Create a new SimpleExpression
|
static StringExpression |
Expressions.asString(Expression<java.lang.String> expr)
Create a new StringExpression
|
static <T extends java.lang.Comparable<?>> |
Expressions.asTime(Expression<T> expr)
Create a new TimeExpression
|
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.atan(Expression<A> num)
Create a
atan(num) expression |
BooleanExpression |
TemporalExpression.before(Expression<T> right)
Create a
this < right expression |
<A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.between(@Nullable Expression<A> from,
@Nullable Expression<A> to)
Create a
this between from and to expression |
<A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.between(@Nullable Expression<A> from,
@Nullable Expression<A> to)
Create a
this between from and to expression |
BooleanExpression |
ComparableExpression.between(@Nullable Expression<T> from,
@Nullable Expression<T> to)
Create a
this between from and to expression |
BooleanExpression |
ComparableExpression.between(@Nullable Expression<T> from,
@Nullable Expression<T> to)
Create a
this between from and to expression |
static BooleanOperation |
Expressions.booleanOperation(Operator operator,
Expression<?>... args)
Create a new Boolean operation
|
SimpleExpression<java.lang.Character> |
StringExpression.charAt(Expression<java.lang.Integer> i)
Create a
this.charAt(i) expression |
ComparableExpressionBase<T> |
ComparableExpressionBase.coalesce(Expression<?>... exprs)
Create a
coalesce(this, exprs...) expression |
BooleanExpression |
BooleanExpression.coalesce(Expression<?>... exprs)
Create a
coalesce(this, exprs...) expression |
DateTimeExpression<T> |
DateTimeExpression.coalesce(Expression<?>... exprs)
Create a
coalesce(this, exprs...) expression |
EnumExpression<T> |
EnumExpression.coalesce(Expression<?>... exprs)
Create a
coalesce(this, exprs...) expression |
DateExpression<T> |
DateExpression.coalesce(Expression<?>... exprs)
Create a
coalesce(this, exprs...) expression |
TimeExpression<T> |
TimeExpression.coalesce(Expression<?>... exprs)
Create a
coalesce(this, exprs...) expression |
ComparableExpression<T> |
ComparableExpression.coalesce(Expression<?>... exprs)
Create a
coalesce(this, exprs...) expression |
StringExpression |
StringExpression.coalesce(Expression<?>... exprs)
Create a
coalesce(this, exprs...) expression |
NumberExpression<T> |
NumberExpression.coalesce(Expression<?>... exprs)
Create a
coalesce(this, exprs...) expression |
BooleanExpression |
BooleanExpression.coalesce(Expression<java.lang.Boolean> expr)
Create a
coalesce(this, expr) expression |
StringExpression |
StringExpression.coalesce(Expression<java.lang.String> expr)
Create a
coalesce(this, expr) expression |
ComparableExpressionBase<T> |
ComparableExpressionBase.coalesce(Expression<T> expr)
Create a
coalesce(this, expr) expression |
DateTimeExpression<T> |
DateTimeExpression.coalesce(Expression<T> expr)
Create a
coalesce(this, expr) expression |
EnumExpression<T> |
EnumExpression.coalesce(Expression<T> expr)
Create a
coalesce(this, expr) expression |
DateExpression<T> |
DateExpression.coalesce(Expression<T> expr)
Create a
coalesce(this, expr) expression |
TimeExpression<T> |
TimeExpression.coalesce(Expression<T> expr)
Create a
coalesce(this, expr) expression |
ComparableExpression<T> |
ComparableExpression.coalesce(Expression<T> expr)
Create a
coalesce(this, expr) expression |
NumberExpression<T> |
NumberExpression.coalesce(Expression<T> expr)
Create a
coalesce(this, expr) expression |
static <T> CollectionExpression<java.util.Collection<T>,T> |
Expressions.collectionOperation(java.lang.Class<T> elementType,
Operator operator,
Expression<?>... args)
Create a new Collection operation expression
|
static <T extends java.lang.Comparable<?>> |
Expressions.comparableOperation(java.lang.Class<? extends T> type,
Operator operator,
Expression<?>... args)
Create a new Operation expression
|
StringExpression |
StringExpression.concat(Expression<java.lang.String> str)
Create a
concat(this, str) expression |
BooleanExpression |
CollectionExpressionBase.contains(Expression<E> child)
Create a
this.contains(child) expression |
BooleanExpression |
MapExpressionBase.contains(Expression<K> key,
Expression<V> value)
Create a
(key, value) in this expression |
BooleanExpression |
MapExpressionBase.contains(Expression<K> key,
Expression<V> value)
Create a
(key, value) in this expression |
BooleanExpression |
StringExpression.contains(Expression<java.lang.String> str)
Create a
this.contains(str) expression |
BooleanExpression |
StringExpression.containsIgnoreCase(Expression<java.lang.String> str)
Create a
this.containsIgnoreCase(str) expression |
BooleanExpression |
MapExpressionBase.containsKey(Expression<K> key)
Create a
key in keys(this) expression |
BooleanExpression |
MapExpressionBase.containsValue(Expression<V> value)
Create a
value in values(this) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.cos(Expression<A> num)
Create a
cos(num) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.cosh(Expression<A> num)
Create a
cosh(num) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.cot(Expression<A> num)
Create a
cot(num) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.coth(Expression<A> num)
Create a
coth(num) expression |
protected abstract Q |
CaseBuilder.Cases.createResult(java.lang.Class<? extends A> type,
Expression<A> last) |
protected abstract Q |
CaseForEqBuilder.Cases.createResult(java.lang.Class<T> type,
Expression<T> last) |
static <T extends java.lang.Comparable<?>> |
Expressions.dateOperation(java.lang.Class<? extends T> type,
Operator operator,
Expression<?>... args)
Create a new Operation expression
|
static <T extends java.lang.Comparable<?>> |
Expressions.dateTimeOperation(java.lang.Class<? extends T> type,
Operator operator,
Expression<?>... args)
Create a new Operation expression
|
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.degrees(Expression<A> num)
Create a
deg(num) expression |
<N extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.divide(Expression<N> right)
Create a
this / right expression |
static <T> DslOperation<T> |
Expressions.dslOperation(java.lang.Class<? extends T> type,
Operator operator,
Expression<?>... args)
Create a new Operation expression
|
BooleanExpression |
StringExpression.endsWith(Expression<java.lang.String> str)
Create a
this.endsWith(str) expression |
BooleanExpression |
StringExpression.endsWithIgnoreCase(Expression<java.lang.String> str)
Create a
this.endsWithIgnoreCase(str) expression |
static <T extends java.lang.Enum<T>> |
Expressions.enumOperation(java.lang.Class<? extends T> type,
Operator operator,
Expression<?>... args)
Create a new Enum operation expression
|
BooleanExpression |
SimpleExpression.eq(Expression<? super T> right)
Create a
this == right expression |
BooleanExpression |
StringExpression.equalsIgnoreCase(Expression<java.lang.String> str)
Create a
this.equalsIgnoreCase(str) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.exp(Expression<A> num)
Create a
exp(num) expression |
protected PathMetadata |
ListPath.forListAccess(Expression<java.lang.Integer> index) |
protected PathMetadata |
MapPath.forMapAccess(Expression<K> key) |
Q |
ListPath.get(Expression<java.lang.Integer> index) |
SimplePath<E> |
ArrayPath.get(Expression<java.lang.Integer> index) |
Q |
ListExpression.get(Expression<java.lang.Integer> index)
Indexed access, gets the element at the given index
|
SimpleExpression<T> |
ArrayExpression.get(Expression<java.lang.Integer> index)
Create a
this[index] expression |
abstract Q |
MapExpressionBase.get(Expression<K> key)
Create a
this.get(key) expression |
E |
MapPath.get(Expression<K> key) |
<A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.goe(Expression<A> right)
Create a
this >= right expression |
BooleanExpression |
ComparableExpression.goe(Expression<T> right)
Create a
this >= right expression |
<A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.gt(Expression<A> right)
Create a
this > right expression |
BooleanExpression |
ComparableExpression.gt(Expression<T> right)
Create a
this > right expression |
BooleanExpression |
SimpleExpression.in(Expression<? extends T>... right)
Create a
this in right expression |
NumberExpression<java.lang.Integer> |
StringExpression.indexOf(Expression<java.lang.String> str)
Create a
this.indexOf(str) expression |
NumberExpression<java.lang.Integer> |
StringExpression.indexOf(Expression<java.lang.String> str,
int i)
Create a
this.indexOf(str) expression |
BooleanExpression |
StringExpression.like(Expression<java.lang.String> str)
Create a
this like str expression |
BooleanExpression |
NumberExpression.like(Expression<java.lang.String> str)
Create a
this like str expression |
BooleanExpression |
StringExpression.like(Expression<java.lang.String> str,
char escape)
Create a
this like str expression |
BooleanExpression |
StringExpression.likeIgnoreCase(Expression<java.lang.String> str)
Create a
this like str expression ignoring case |
BooleanExpression |
StringExpression.likeIgnoreCase(Expression<java.lang.String> str,
char escape)
Create a
this like str expression ignoring case |
static <T> Expression<T> |
Expressions.list(java.lang.Class<T> clazz,
Expression<?>... exprs)
Combine the given expressions into a list expression
|
static Expression<Tuple> |
Expressions.list(Expression<?>... exprs)
Combine the given expressions into a list expression
|
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.ln(Expression<A> num)
Create a
ln(num) expression |
NumberExpression<java.lang.Integer> |
StringExpression.locate(Expression<java.lang.String> str)
Create a
locate(str, this) expression |
NumberExpression<java.lang.Integer> |
StringExpression.locate(Expression<java.lang.String> str,
NumberExpression<java.lang.Integer> start)
Create a
locate(str, this, start) expression |
NumberExpression<java.lang.Integer> |
StringExpression.locate(java.lang.String str,
Expression<java.lang.Integer> start)
Create a
locate(str, this, start) expression |
<A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.loe(Expression<A> right)
Create a
this <= right expression |
BooleanExpression |
ComparableExpression.loe(Expression<T> right)
Create a
this <= right expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.log(Expression<A> num,
int base)
Create a
log(num, base) expression |
static StringExpression |
StringExpressions.lpad(Expression<java.lang.String> in,
Expression<java.lang.Integer> length)
Create a
lpad(in, length) expression |
static StringExpression |
StringExpressions.lpad(Expression<java.lang.String> in,
Expression<java.lang.Integer> length)
Create a
lpad(in, length) expression |
static StringExpression |
StringExpressions.lpad(Expression<java.lang.String> in,
int length)
Create a
lpad(in, length) expression |
static StringExpression |
StringExpressions.lpad(Expression<java.lang.String> in,
int length,
char c)
Create a
lpad(in, length, c) expression |
static StringExpression |
StringExpressions.lpad(Expression<java.lang.String> in,
NumberExpression<java.lang.Integer> length,
char c)
Create a
lpad(in, length, c) expression |
<A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.lt(Expression<A> right)
Create a
this < right expression |
BooleanExpression |
ComparableExpression.lt(Expression<T> right)
Create a
this < right expression |
static StringExpression |
StringExpressions.ltrim(Expression<java.lang.String> str)
Create a
ltrim(str) expression |
BooleanExpression |
StringExpression.matches(Expression<java.lang.String> regex)
Create a
this.matches(regex) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.max(Expression<A> left,
Expression<A> right)
Create a
max(left, right) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.max(Expression<A> left,
Expression<A> right)
Create a
max(left, right) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.max(Expression<A> left,
Expression<A> right)
Create a
max(left, right) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.max(Expression<A> left,
Expression<A> right)
Create a
max(left, right) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.min(Expression<A> left,
Expression<A> right)
Create a
min(left, right) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.min(Expression<A> left,
Expression<A> right)
Create a
min(left, right) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.min(Expression<A> left,
Expression<A> right)
Create a
min(left, right) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.min(Expression<A> left,
Expression<A> right)
Create a
min(left, right) expression |
NumberExpression<T> |
NumberExpression.mod(Expression<T> num)
Create a
mod(this, num) expression |
<N extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.multiply(Expression<N> right)
Create a
this * right expression |
BooleanExpression |
SimpleExpression.ne(Expression<? super T> right)
Create a
this <> right expression |
<A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.notBetween(Expression<A> from,
Expression<A> to)
Create a
this not between from and to expression |
<A extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.notBetween(Expression<A> from,
Expression<A> to)
Create a
this not between from and to expression |
BooleanExpression |
ComparableExpression.notBetween(Expression<T> from,
Expression<T> to)
Create a
this not between from and to expression |
BooleanExpression |
ComparableExpression.notBetween(Expression<T> from,
Expression<T> to)
Create a
this not between from and to expression |
BooleanExpression |
StringExpression.notEqualsIgnoreCase(Expression<java.lang.String> str)
Create a
!this.equalsIgnoreCase(str) expression |
BooleanExpression |
SimpleExpression.notIn(Expression<? extends T>... right)
Create a
this not in right expression |
BooleanExpression |
StringExpression.notLike(Expression<java.lang.String> str)
Create a
this not like str expression |
BooleanExpression |
StringExpression.notLike(Expression<java.lang.String> str,
char escape)
Create a
this not like str expression |
BooleanExpression |
BooleanExpression.nullif(Expression<java.lang.Boolean> other)
Create a
nullif(this, other) expression |
StringExpression |
StringExpression.nullif(Expression<java.lang.String> other)
Create a
nullif(this, other) expression |
ComparableExpressionBase<T> |
ComparableExpressionBase.nullif(Expression<T> other)
Create a
nullif(this, other) expression |
DateTimeExpression<T> |
DateTimeExpression.nullif(Expression<T> other)
Create a
nullif(this, other) expression |
EnumExpression<T> |
EnumExpression.nullif(Expression<T> other)
Create a
nullif(this, other) expression |
DateExpression<T> |
DateExpression.nullif(Expression<T> other)
Create a
nullif(this, other) expression |
TimeExpression<T> |
TimeExpression.nullif(Expression<T> other)
Create a
nullif(this, other) expression |
ComparableExpression<T> |
ComparableExpression.nullif(Expression<T> other)
Create a
nullif(this, other) expression |
SimpleExpression<T> |
SimpleExpression.nullif(Expression<T> other)
Create a
nullif(this, other) expression |
NumberExpression<T> |
NumberExpression.nullif(Expression<T> other)
Create a
nullif(this, other) expression |
static <T extends java.lang.Number & java.lang.Comparable<?>> |
Expressions.numberOperation(java.lang.Class<? extends T> type,
Operator operator,
Expression<?>... args)
Create a new Operation expression
|
static <T> SimpleOperation<T> |
Expressions.operation(java.lang.Class<? extends T> type,
Operator operator,
Expression<?>... args)
Create a new Operation expression
|
Q |
CaseBuilder.Cases.otherwise(Expression<A> expr) |
Q |
CaseForEqBuilder.Cases.otherwise(Expression<T> otherwise) |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.power(Expression<A> num,
int exponent)
Create a
power(num, exponent) expression |
static BooleanOperation |
Expressions.predicate(Operator operator,
Expression<?>... args)
Create a new Predicate operation
|
StringExpression |
StringExpression.prepend(Expression<java.lang.String> str)
Create a
concat(str, this) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.radians(Expression<A> num)
Create a
rad(num) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.round(Expression<A> num)
Round to nearest integer
|
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.round(Expression<A> num,
int s)
Round to s decimal places
|
static StringExpression |
StringExpressions.rpad(Expression<java.lang.String> in,
Expression<java.lang.Integer> length)
Create a
rpad(in, length) expression |
static StringExpression |
StringExpressions.rpad(Expression<java.lang.String> in,
Expression<java.lang.Integer> length)
Create a
rpad(in, length) expression |
static StringExpression |
StringExpressions.rpad(Expression<java.lang.String> in,
int length)
Create a
rpad(in, length) expression |
static StringExpression |
StringExpressions.rpad(Expression<java.lang.String> in,
int length,
char c)
Create a
rpad(in, length, c) expression |
static StringExpression |
StringExpressions.rpad(Expression<java.lang.String> in,
NumberExpression<java.lang.Integer> length,
char c)
Create a
rpad(in, length, c) expression |
static StringExpression |
StringExpressions.rtrim(Expression<java.lang.String> str)
Create a
rtrim(str) expression |
static <T> Expression<T> |
Expressions.set(java.lang.Class<T> clazz,
Expression<?>... exprs)
Combine the given expressions into a set expression
|
static Expression<Tuple> |
Expressions.set(Expression<?>... exprs)
Combine the given expressions into a set expression
|
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.sign(Expression<A> num)
Create a
sign(num) expression |
static <T> SimpleOperation<T> |
Expressions.simpleOperation(java.lang.Class<? extends T> type,
Operator operator,
Expression<?>... args)
Create a new Operation expression
|
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.sin(Expression<A> num)
Create a
sin(num) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.sinh(Expression<A> num)
Create a
sinh(num) expression |
BooleanExpression |
StringExpression.startsWith(Expression<java.lang.String> str)
Create a
this.startsWith(str) expression |
BooleanExpression |
StringExpression.startsWithIgnoreCase(Expression<java.lang.String> str)
Create a
this.startsWithIgnoreCase(str) expression |
static StringOperation |
Expressions.stringOperation(Operator operator,
Expression<?>... args)
Create a new Operation expression
|
StringExpression |
StringExpression.substring(Expression<java.lang.Integer> beginIndex)
Create a
this.substring(beginIndex) expression |
StringExpression |
StringExpression.substring(Expression<java.lang.Integer> beginIndex,
Expression<java.lang.Integer> endIndex)
Create a
this.substring(beginIndex, endIndex) expression |
StringExpression |
StringExpression.substring(Expression<java.lang.Integer> beginIndex,
Expression<java.lang.Integer> endIndex)
Create a
this.substring(beginIndex, endIndex) expression |
StringExpression |
StringExpression.substring(Expression<java.lang.Integer> beginIndex,
int endIndex)
Create a
this.substring(beginIndex, endIndex) expression |
StringExpression |
StringExpression.substring(int beginIndex,
Expression<java.lang.Integer> endIndex)
Create a
this.substring(beginIndex, endIndex) expression |
<N extends java.lang.Number & java.lang.Comparable<?>> |
NumberExpression.subtract(Expression<N> right)
Create a
this - right expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.tan(Expression<A> num)
Create a
tan(num) expression |
static <A extends java.lang.Number & java.lang.Comparable<?>> |
MathExpressions.tanh(Expression<A> num)
Create a
tanh(num) expression |
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> expr) |
<T extends java.lang.Number & java.lang.Comparable<?>> |
CaseForEqBuilder.thenNumber(Expression<T> then) |
static <T extends java.lang.Comparable<?>> |
Expressions.timeOperation(java.lang.Class<? extends T> type,
Operator operator,
Expression<?>... args)
Create a new Operation expression
|
CaseForEqBuilder.CaseWhen<T,Q> |
CaseForEqBuilder.Cases.when(Expression<? extends D> when) |
CaseForEqBuilder<T> |
SimpleExpression.when(Expression<? extends T> other)
Create a case expression builder
|
Constructor and Description |
---|
BooleanOperation(Operator op,
java.util.List<Expression<?>> args) |
CollectionOperation(java.lang.Class<? super E> type,
Operator op,
java.util.List<Expression<?>> args) |
ComparableOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
DateOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
DateTimeOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
DslOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
EnumOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
NumberOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
SimpleOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
StringOperation(Operator op,
java.util.List<Expression<?>> args) |
TimeOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
Modifier and Type | Interface and Description |
---|---|
interface |
JDOQLQuery<T>
Query interface for JDOQL queries
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractJDOQuery<T,Q extends AbstractJDOQuery<T,Q>>
Abstract base class for custom implementations of the
JDOQLQuery interface. |
class |
JDOQuery<T>
JDOQuery is the default implementation of the JDOQLQuery interface |
Modifier and Type | Method and Description |
---|---|
Expression<?> |
JDOQLSerializer.getCandidatePath() |
Modifier and Type | Method and Description |
---|---|
JDOQuery<Tuple> |
JDOQueryFactory.select(Expression<?>... exprs)
Create a new
JDOQuery instance with the given projection |
static JDOQuery<Tuple> |
JDOExpressions.select(Expression<?>... exprs)
Create a new detached
JDOQuery instance with the given projection |
JDOQuery<Tuple> |
JDOQuery.select(Expression<?>... exprs) |
<T> JDOQuery<T> |
JDOQueryFactory.select(Expression<T> expr)
Create a new
JDOQuery instance with the given projection |
static <T> JDOQuery<T> |
JDOExpressions.select(Expression<T> expr)
Create a new detached
JDOQuery instance with the given projection |
<U> JDOQuery<U> |
JDOQuery.select(Expression<U> expr) |
JDOQuery<Tuple> |
JDOQueryFactory.selectDistinct(Expression<?>... exprs)
Create a new
JDOQuery instance with the given projection |
static JDOQuery<Tuple> |
JDOExpressions.selectDistinct(Expression<?>... exprs)
Create a new detached
JDOQuery instance with the given projection |
<T> JDOQuery<T> |
JDOQueryFactory.selectDistinct(Expression<T> expr)
Create a new
JDOQuery instance with the given projection |
static <T> JDOQuery<T> |
JDOExpressions.selectDistinct(Expression<T> expr)
Create a new detached
JDOQuery instance with the given projection |
Modifier and Type | Method and Description |
---|---|
protected void |
JDOQLSerializer.visitOperation(java.lang.Class<?> type,
Operator operator,
java.util.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 | Class and Description |
---|---|
class |
JDOSQLQuery<T>
JDOSQLQuery is a SQLQuery implementation that uses JDO's SQL query functionality
to execute queries |
Modifier and Type | Method and Description |
---|---|
JDOSQLQuery<Tuple> |
JDOSQLQuery.select(Expression<?>... exprs) |
<U> JDOSQLQuery<U> |
JDOSQLQuery.select(Expression<U> expr) |
Modifier and Type | Interface and Description |
---|---|
interface |
JPQLQuery<T>
Query interface for JPQL queries
|
Modifier and Type | Class and Description |
---|---|
class |
JPAQueryBase<T,Q extends JPAQueryBase<T,Q>>
JPAQueryBase is a base Query class for JPA queries |
Modifier and Type | Method and Description |
---|---|
static <RT> Expression<RT> |
Conversions.convert(Expression<RT> expr) |
<RT> Expression<RT> |
JPAQueryMixin.convert(Expression<RT> expr,
QueryMixin.Role role) |
static <RT> Expression<RT> |
Conversions.convertForNativeQuery(Expression<RT> expr) |
protected <D> Expression<D> |
JPAQueryMixin.createAlias(Expression<?> expr,
Path<D> alias) |
protected Expression<?> |
AbstractSQLQuery.extractEntityExpression(Expression<?> expr) |
Modifier and Type | Method and Description |
---|---|
java.util.Map<Expression<?>,java.util.List<java.lang.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,
QueryMixin.Role role) |
static <RT> Expression<RT> |
Conversions.convertForNativeQuery(Expression<RT> expr) |
protected <D> Expression<D> |
JPAQueryMixin.createAlias(Expression<?> expr,
Path<D> alias) |
protected Expression<?> |
AbstractSQLQuery.extractEntityExpression(Expression<?> expr) |
protected boolean |
AbstractSQLQuery.isEntityExpression(Expression<?> expr) |
JPQLQuery<Tuple> |
JPQLQuery.select(Expression<?>... exprs) |
static JPQLQuery<Tuple> |
JPAExpressions.select(Expression<?>... exprs)
Create a new detached JPQLQuery instance with the given projection
|
JPQLQuery<Tuple> |
JPQLQueryFactory.select(Expression<?>... exprs)
Create a new JPQLQuery instance with the given projection
|
static <T> JPQLQuery<T> |
JPAExpressions.select(Expression<T> expr)
Create a new detached JPQLQuery instance with the given projection
|
<T> JPQLQuery<T> |
JPQLQueryFactory.select(Expression<T> expr)
Create a new JPQLQuery instance with the given projection
|
<U> JPQLQuery<U> |
JPQLQuery.select(Expression<U> expr) |
static JPQLQuery<Tuple> |
JPAExpressions.selectDistinct(Expression<?>... exprs)
Create a new detached JPQLQuery instance with the given projection
|
JPQLQuery<Tuple> |
JPQLQueryFactory.selectDistinct(Expression<?>... exprs)
Create a new JPQLQuery instance with the given projection
|
static <T> JPQLQuery<T> |
JPAExpressions.selectDistinct(Expression<T> expr)
Create a new detached JPQLQuery instance with the given projection
|
<T> JPQLQuery<T> |
JPQLQueryFactory.selectDistinct(Expression<T> expr)
Create a new JPQLQuery instance with the given projection
|
Modifier and Type | Method and Description |
---|---|
void |
JPQLSerializer.serializeForInsert(QueryMetadata md,
java.util.Collection<Path<?>> columns,
java.util.List<java.lang.Object> values,
SubQueryExpression<?> query,
java.util.Map<Path<?>,Expression<?>> inserts) |
void |
JPQLSerializer.serializeForUpdate(QueryMetadata md,
java.util.Map<Path<?>,Expression<?>> updates) |
protected void |
JPQLSerializer.visitOperation(java.lang.Class<?> type,
Operator operator,
java.util.List<? extends Expression<?>> args) |
protected void |
NativeSQLSerializer.visitOperation(java.lang.Class<?> type,
Operator operator,
java.util.List<? extends Expression<?>> args) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractHibernateQuery<T,Q extends AbstractHibernateQuery<T,Q>>
Abstract base class for Hibernate API based implementations of the JPQL interface
|
class |
HibernateQuery<T>
HibernateQuery is the default implementation of the JPQLQuery interface for Hibernate |
Modifier and Type | Method and Description |
---|---|
HibernateQuery<Tuple> |
HibernateQueryFactory.select(Expression<?>... exprs) |
HibernateQuery<Tuple> |
HibernateQuery.select(Expression<?>... exprs) |
<T> HibernateQuery<T> |
HibernateQueryFactory.select(Expression<T> expr) |
<U> HibernateQuery<U> |
HibernateQuery.select(Expression<U> expr) |
HibernateQuery<Tuple> |
HibernateQueryFactory.selectDistinct(Expression<?>... exprs) |
<T> HibernateQuery<T> |
HibernateQueryFactory.selectDistinct(Expression<T> expr) |
<T> HibernateUpdateClause |
HibernateUpdateClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> HibernateInsertClause |
HibernateInsertClause.set(Path<T> path,
Expression<? extends T> expression) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractHibernateSQLQuery<T,Q extends AbstractHibernateSQLQuery<T,Q>>
AbstractHibernateSQLQuery is the base class for Hibernate Native SQL queries |
class |
HibernateSQLQuery<T>
HibernateSQLQuery is an SQLQuery implementation that uses Hibernate's Native SQL functionality
to execute queries |
Modifier and Type | Method and Description |
---|---|
HibernateSQLQuery<Tuple> |
HibernateSQLQuery.select(Expression<?>... exprs) |
<U> HibernateSQLQuery<U> |
HibernateSQLQuery.select(Expression<U> expr) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractJPAQuery<T,Q extends AbstractJPAQuery<T,Q>>
Abstract base class for JPA API based implementations of the JPQLQuery interface
|
class |
JPAQuery<T>
JPAQuery is the default implementation of the JPQLQuery interface for JPA |
Modifier and Type | Method and Description |
---|---|
JPAQuery<Tuple> |
JPAQuery.select(Expression<?>... exprs) |
JPAQuery<Tuple> |
JPAQueryFactory.select(Expression<?>... exprs) |
<T> JPAQuery<T> |
JPAQueryFactory.select(Expression<T> expr) |
<U> JPAQuery<U> |
JPAQuery.select(Expression<U> expr) |
JPAQuery<Tuple> |
JPAQueryFactory.selectDistinct(Expression<?>... exprs) |
<T> JPAQuery<T> |
JPAQueryFactory.selectDistinct(Expression<T> expr) |
<T> JPAUpdateClause |
JPAUpdateClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> JPAInsertClause |
JPAInsertClause.set(Path<T> path,
Expression<? extends T> expression) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractJPASQLQuery<T,Q extends AbstractJPASQLQuery<T,Q>>
AbstractJPASQLQuery is the base class for JPA Native SQL queries |
class |
JPASQLQuery<T>
JPASQLQuery is an SQLQuery implementation that uses JPA Native SQL functionality
to execute queries |
Modifier and Type | Method and Description |
---|---|
JPASQLQuery<Tuple> |
JPASQLQuery.select(Expression<?>... exprs) |
<U> JPASQLQuery<U> |
JPASQLQuery.select(Expression<U> 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 java.lang.String[] |
LuceneSerializer.convert(Path<?> leftHandSide,
Expression<?> rightHandSide,
QueryMetadata metadata)
template method
|
protected org.apache.lucene.search.Query |
LuceneSerializer.range(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.range(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.stringRange(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.stringRange(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
org.apache.lucene.search.Query |
LuceneSerializer.toQuery(Expression<?> expr,
QueryMetadata metadata) |
Modifier and Type | Method and Description |
---|---|
protected java.lang.String[] |
LuceneSerializer.convert(Path<?> leftHandSide,
Expression<?> rightHandSide,
QueryMetadata metadata)
template method
|
protected org.apache.lucene.search.Query |
LuceneSerializer.range(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.range(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.stringRange(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.stringRange(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
org.apache.lucene.search.Query |
LuceneSerializer.toQuery(Expression<?> expr,
QueryMetadata metadata) |
Modifier and Type | Method and Description |
---|---|
protected java.lang.String[] |
LuceneSerializer.convert(Path<?> leftHandSide,
Expression<?> rightHandSide,
QueryMetadata metadata)
template method
|
protected org.apache.lucene.search.Query |
LuceneSerializer.range(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.range(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.stringRange(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.stringRange(Path<?> leftHandSide,
java.lang.String field,
@Nullable Expression<?> min,
@Nullable 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 |
---|---|
protected com.mongodb.DBCursor |
AbstractMongodbQuery.createCursor(com.mongodb.DBCollection collection,
@Nullable Predicate where,
Expression<?> projection,
QueryModifiers modifiers,
java.util.List<OrderSpecifier<?>> orderBy) |
java.lang.Object |
MongodbSerializer.handle(Expression<?> expression) |
static BooleanExpression |
MongodbExpressions.near(Expression<java.lang.Double[]> expr,
double latVal,
double longVal)
Finds the closest points relative to the given location and orders the results with decreasing proximity
|
static BooleanExpression |
MongodbExpressions.nearSphere(Expression<java.lang.Double[]> expr,
double latVal,
double longVal)
Finds the closest points relative to the given location on a sphere and orders the results with decreasing proximity
|
static BooleanExpression |
MongodbExpressions.withinBox(Expression<java.lang.Double[]> expr,
double blLongVal,
double blLatVal,
double urLongVal,
double urLatVal)
Finds points within bounds of the rectangle
|
Modifier and Type | Method and Description |
---|---|
protected com.mongodb.client.FindIterable<org.bson.Document> |
AbstractFetchableMongodbQuery.createCursor(com.mongodb.client.MongoCollection<org.bson.Document> collection,
@Nullable Predicate where,
Expression<?> projection,
QueryModifiers modifiers,
java.util.List<OrderSpecifier<?>> orderBy) |
protected org.bson.Document |
AbstractMongodbQuery.createProjection(Expression<?> projection) |
java.lang.Object |
MongodbDocumentSerializer.handle(Expression<?> expression) |
static BooleanExpression |
MongodbExpressions.near(Expression<java.lang.Double[]> expr,
double latVal,
double longVal)
Finds the closest points relative to the given location and orders the results with decreasing proximity
|
static BooleanExpression |
MongodbExpressions.nearSphere(Expression<java.lang.Double[]> expr,
double latVal,
double longVal)
Finds the closest points relative to the given location on a sphere and orders the results with decreasing proximity
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractGeometryCollectionExpression<T extends org.geolatte.geom.AbstractGeometryCollection>
A GeometryCollection is a geometric object that is a collection of some number of geometric objects.
|
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 |
GeometryCollectionPath<T extends org.geolatte.geom.GeometryCollection>
|
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 |
GeometryPath<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 |
LinearRingPath<T extends org.geolatte.geom.LinearRing>
|
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 |
LineStringPath<T extends org.geolatte.geom.LineString>
|
class |
MultiCurveExpression<T extends org.geolatte.geom.AbstractGeometryCollection>
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 |
MultiLineStringPath<T extends org.geolatte.geom.MultiLineString>
|
class |
MultiPointExpression<T extends org.geolatte.geom.MultiPoint>
A MultiPoint is a 0-dimensional GeometryCollection.
|
class |
MultiPointPath<T extends org.geolatte.geom.MultiPoint>
|
class |
MultiPolygonExpression<T extends org.geolatte.geom.MultiPolygon>
A MultiPolygon is a MultiSurface whose elements are Polygons.
|
class |
MultiPolygonPath<T extends org.geolatte.geom.MultiPolygon>
|
class |
MultiSurfaceExpression<T extends org.geolatte.geom.AbstractGeometryCollection>
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 |
PointPath<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 |
PolygonPath<T extends org.geolatte.geom.Polygon>
|
class |
SurfaceExpression<T extends org.geolatte.geom.Geometry>
A Surface is a 2-dimensional geometric object.
|
Modifier and Type | Method and Description |
---|---|
Expression<?> |
LineStringOperation.getArg(int index) |
Expression<?> |
PolygonOperation.getArg(int index) |
Expression<?> |
GeometryOperation.getArg(int index) |
Expression<?> |
PointOperation.getArg(int index) |
Modifier and Type | Method and Description |
---|---|
java.util.List<Expression<?>> |
LineStringOperation.getArgs() |
java.util.List<Expression<?>> |
PolygonOperation.getArgs() |
java.util.List<Expression<?>> |
GeometryOperation.getArgs() |
java.util.List<Expression<?>> |
PointOperation.getArgs() |
Modifier and Type | Method and Description |
---|---|
static <T extends org.geolatte.geom.Geometry> |
GeometryExpressions.asGeometry(Expression<T> expr)
Create a new GeometryExpression
|
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.
|
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<java.lang.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<java.lang.Double> |
GeometryExpression.distanceSphere(Expression<? extends org.geolatte.geom.Geometry> geometry) |
NumberExpression<java.lang.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<java.lang.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<java.lang.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<java.lang.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<java.lang.String> text)
Return a specified ST_Geometry value from Well-Known Text representation (WKT).
|
static <T extends org.geolatte.geom.Geometry> |
GeometryExpressions.geometryOperation(java.lang.Class<? extends T> type,
Operator op,
Expression<?>... args)
Create a new Geometry operation expression
|
static GeometryExpression<org.geolatte.geom.Geometry> |
GeometryExpressions.geometryOperation(Operator op,
Expression<?>... args)
Create a new Geometry operation expression
|
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.
|
static LineStringExpression<org.geolatte.geom.LineString> |
GeometryExpressions.lineStringOperation(Operator op,
Expression<?>... args)
Create a new LineString operation expression
|
BooleanExpression |
GeometryExpression.overlaps(Expression<? extends org.geolatte.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially overlaps” anotherGeometry.
|
static PointExpression<org.geolatte.geom.Point> |
GeometryExpressions.pointOperation(Operator op,
Expression<?>... args)
Create a new Point operation expression
|
static PolygonExpression<org.geolatte.geom.Polygon> |
GeometryExpressions.polygonOperation(Operator op,
Expression<?>... args)
Create a new Polygon operation expression
|
BooleanExpression |
GeometryExpression.relate(Expression<? extends org.geolatte.geom.Geometry> geometry,
java.lang.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(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
LineStringOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
PointOperation(java.lang.Class<T> type,
Operator op,
java.util.List<Expression<?>> args) |
PolygonOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
Modifier and Type | Method and Description |
---|---|
Expression<?> |
JTSGeometryOperation.getArg(int index) |
Expression<?> |
JTSLineStringOperation.getArg(int index) |
Expression<?> |
JTSPointOperation.getArg(int index) |
Expression<?> |
JTSPolygonOperation.getArg(int index) |
Modifier and Type | Method and Description |
---|---|
java.util.List<Expression<?>> |
JTSGeometryOperation.getArgs() |
java.util.List<Expression<?>> |
JTSLineStringOperation.getArgs() |
java.util.List<Expression<?>> |
JTSPointOperation.getArgs() |
java.util.List<Expression<?>> |
JTSPolygonOperation.getArgs() |
Modifier and Type | Method and Description |
---|---|
static <T extends com.vividsolutions.jts.geom.Geometry> |
JTSGeometryExpressions.asJTSGeometry(Expression<T> expr)
Create a new JTSGeometryExpression
|
static JTSGeometryExpression<?> |
JTSGeometryExpressions.collect(Expression<? extends com.vividsolutions.jts.geom.Geometry> expr1,
Expression<? extends com.vividsolutions.jts.geom.Geometry> expr2)
Return a specified ST_Geometry value from a collection of other geometries.
|
static JTSGeometryExpression<?> |
JTSGeometryExpressions.collect(Expression<? extends com.vividsolutions.jts.geom.Geometry> expr1,
Expression<? extends com.vividsolutions.jts.geom.Geometry> expr2)
Return a specified ST_Geometry value from a collection of other geometries.
|
static JTSGeometryExpression<?> |
JTSGeometryExpressions.collect(Expression<? extends com.vividsolutions.jts.geom.GeometryCollection> collection)
Return a specified ST_Geometry value from a collection of other geometries.
|
BooleanExpression |
JTSGeometryExpression.contains(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially contains” anotherGeometry.
|
BooleanExpression |
JTSGeometryExpression.crosses(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially crosses’ anotherGeometry.
|
JTSGeometryExpression<com.vividsolutions.jts.geom.Geometry> |
JTSGeometryExpression.difference(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry)
Returns a geometric object that represents the Point
set difference of this geometric object with anotherGeometry.
|
BooleanExpression |
JTSGeometryExpression.disjoint(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object is “spatially disjoint” from anotherGeometry.
|
NumberExpression<java.lang.Double> |
JTSGeometryExpression.distance(Expression<? extends com.vividsolutions.jts.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<java.lang.Double> |
JTSGeometryExpression.distanceSphere(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry) |
NumberExpression<java.lang.Double> |
JTSGeometryExpression.distanceSpheroid(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry) |
static BooleanExpression |
JTSGeometryExpressions.dwithin(Expression<? extends com.vividsolutions.jts.geom.Geometry> expr1,
Expression<? extends com.vividsolutions.jts.geom.Geometry> expr2,
double distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
JTSGeometryExpressions.dwithin(Expression<? extends com.vividsolutions.jts.geom.Geometry> expr1,
Expression<? extends com.vividsolutions.jts.geom.Geometry> expr2,
double distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
JTSGeometryExpressions.dwithin(Expression<? extends com.vividsolutions.jts.geom.Geometry> expr1,
Expression<? extends com.vividsolutions.jts.geom.Geometry> expr2,
Expression<java.lang.Double> distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
JTSGeometryExpressions.dwithin(Expression<? extends com.vividsolutions.jts.geom.Geometry> expr1,
Expression<? extends com.vividsolutions.jts.geom.Geometry> expr2,
Expression<java.lang.Double> distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
JTSGeometryExpressions.dwithin(Expression<? extends com.vividsolutions.jts.geom.Geometry> expr1,
Expression<? extends com.vividsolutions.jts.geom.Geometry> expr2,
Expression<java.lang.Double> distance)
Returns true if the geometries are within the specified distance of one another.
|
BooleanExpression |
JTSGeometryExpression.eq(Expression<? super T> right) |
static JTSGeometryExpression<?> |
JTSGeometryExpressions.extent(Expression<? extends com.vividsolutions.jts.geom.GeometryCollection> collection)
Returns the bounding box that bounds rows of geometries.
|
static JTSGeometryExpression<?> |
JTSGeometryExpressions.fromText(Expression<java.lang.String> text)
Return a specified ST_Geometry value from Well-Known Text representation (WKT).
|
static <T extends com.vividsolutions.jts.geom.Geometry> |
JTSGeometryExpressions.geometryOperation(java.lang.Class<? extends T> type,
Operator op,
Expression<?>... args)
Create a new Geometry operation expression
|
static JTSGeometryExpression<com.vividsolutions.jts.geom.Geometry> |
JTSGeometryExpressions.geometryOperation(Operator op,
Expression<?>... args)
Create a new Geometry operation expression
|
JTSGeometryExpression<com.vividsolutions.jts.geom.Geometry> |
JTSGeometryExpression.intersection(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry)
Returns a geometric object that represents the Point set intersection of this geometric
object with anotherGeometry.
|
BooleanExpression |
JTSGeometryExpression.intersects(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially intersects” anotherGeometry.
|
static JTSLineStringExpression<com.vividsolutions.jts.geom.LineString> |
JTSGeometryExpressions.lineStringOperation(Operator op,
Expression<?>... args)
Create a new LineString operation expression
|
BooleanExpression |
JTSGeometryExpression.overlaps(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially overlaps” anotherGeometry.
|
static JTSPointExpression<com.vividsolutions.jts.geom.Point> |
JTSGeometryExpressions.pointOperation(Operator op,
Expression<?>... args)
Create a new Point operation expression
|
static JTSPolygonExpression<com.vividsolutions.jts.geom.Polygon> |
JTSGeometryExpressions.polygonOperation(Operator op,
Expression<?>... args)
Create a new Polygon operation expression
|
BooleanExpression |
JTSGeometryExpression.relate(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry,
java.lang.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 com.vividsolutions.jts.geom.Geometry> |
JTSGeometryExpressions.setSRID(Expression<T> expr,
int srid)
Sets the SRID on a geometry to a particular integer value.
|
JTSGeometryExpression<com.vividsolutions.jts.geom.Geometry> |
JTSGeometryExpression.symDifference(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry)
Returns a geometric object that represents the
Point set symmetric difference of this geometric object with anotherGeometry.
|
BooleanExpression |
JTSGeometryExpression.touches(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially touches” anotherGeometry.
|
static <T extends com.vividsolutions.jts.geom.Geometry> |
JTSGeometryExpressions.translate(Expression<T> expr,
float deltax,
float deltay)
Translates the geometry to a new location using the numeric parameters as offsets.
|
static <T extends com.vividsolutions.jts.geom.Geometry> |
JTSGeometryExpressions.translate(Expression<T> expr,
float deltax,
float deltay,
float deltaz)
Translates the geometry to a new location using the numeric parameters as offsets.
|
JTSGeometryExpression<com.vividsolutions.jts.geom.Geometry> |
JTSGeometryExpression.union(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry)
Returns a geometric object that represents the Point set
union of this geometric object with anotherGeometry.
|
BooleanExpression |
JTSGeometryExpression.within(Expression<? extends com.vividsolutions.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object is “spatially within” anotherGeometry.
|
Constructor and Description |
---|
JTSGeometryOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
JTSLineStringOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
JTSPointOperation(java.lang.Class<T> type,
Operator op,
java.util.List<Expression<?>> args) |
JTSPolygonOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
Modifier and Type | Class and Description |
---|---|
class |
JTSCurveExpression<T extends org.locationtech.jts.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 |
JTSGeometryCollectionExpression<T extends org.locationtech.jts.geom.GeometryCollection>
A Geometry collection is a geometric object that is a collection of some number of geometric objects.
|
class |
JTSGeometryCollectionPath<T extends org.locationtech.jts.geom.GeometryCollection>
|
class |
JTSGeometryExpression<T extends org.locationtech.jts.geom.Geometry>
Geometry is the root class of the hierarchy.
|
class |
JTSGeometryOperation<T extends org.locationtech.jts.geom.Geometry>
|
class |
JTSGeometryPath<T extends org.locationtech.jts.geom.Geometry>
|
class |
JTSLinearRingExpression<T extends org.locationtech.jts.geom.LineString>
A LinearRing is a LineString that is both closed and simple.
|
class |
JTSLinearRingPath<T extends org.locationtech.jts.geom.LinearRing>
|
class |
JTSLineExpression<T extends org.locationtech.jts.geom.LineString>
A Line is a LineString with exactly 2 Points.
|
class |
JTSLineStringExpression<T extends org.locationtech.jts.geom.LineString>
A LineString is a Curve with linear interpolation between Points.
|
class |
JTSLineStringOperation<T extends org.locationtech.jts.geom.LineString>
|
class |
JTSLineStringPath<T extends org.locationtech.jts.geom.LineString>
|
class |
JTSMultiCurveExpression<T extends org.locationtech.jts.geom.GeometryCollection>
A MultiCurve is a 1-dimensional GeometryCollection whose elements are Curves.
|
class |
JTSMultiLineStringExpression<T extends org.locationtech.jts.geom.MultiLineString>
A MultiLineString is a MultiCurve whose elements are LineStrings.
|
class |
JTSMultiLineStringPath<T extends org.locationtech.jts.geom.MultiLineString>
|
class |
JTSMultiPointExpression<T extends org.locationtech.jts.geom.MultiPoint>
A MultiPoint is a 0-dimensional GeometryCollection.
|
class |
JTSMultiPointPath<T extends org.locationtech.jts.geom.MultiPoint>
|
class |
JTSMultiPolygonExpression<T extends org.locationtech.jts.geom.MultiPolygon>
A MultiPolygon is a MultiSurface whose elements are Polygons.
|
class |
JTSMultiPolygonPath<T extends org.locationtech.jts.geom.MultiPolygon>
|
class |
JTSMultiSurfaceExpression<T extends org.locationtech.jts.geom.GeometryCollection>
A MultiSurface is a 2-dimensional GeometryCollection whose elements are Surfaces, all using coordinates from
the same coordinate reference system.
|
class |
JTSPointExpression<T extends org.locationtech.jts.geom.Point>
A Point is a 0-dimensional geometric object and represents a single location in coordinate space.
|
class |
JTSPointOperation<T extends org.locationtech.jts.geom.Point>
|
class |
JTSPointPath<T extends org.locationtech.jts.geom.Point>
|
class |
JTSPolygonExpression<T extends org.locationtech.jts.geom.Polygon>
A Polygon is a planar Surface defined by 1 exterior boundary and 0 or more interior boundaries.
|
class |
JTSPolygonOperation<T extends org.locationtech.jts.geom.Polygon>
|
class |
JTSPolygonPath<T extends org.locationtech.jts.geom.Polygon>
|
class |
JTSSurfaceExpression<T extends org.locationtech.jts.geom.Geometry>
A Surface is a 2-dimensional geometric object.
|
Modifier and Type | Method and Description |
---|---|
Expression<?> |
JTSGeometryOperation.getArg(int index) |
Expression<?> |
JTSLineStringOperation.getArg(int index) |
Expression<?> |
JTSPointOperation.getArg(int index) |
Expression<?> |
JTSPolygonOperation.getArg(int index) |
Modifier and Type | Method and Description |
---|---|
java.util.List<Expression<?>> |
JTSGeometryOperation.getArgs() |
java.util.List<Expression<?>> |
JTSLineStringOperation.getArgs() |
java.util.List<Expression<?>> |
JTSPointOperation.getArgs() |
java.util.List<Expression<?>> |
JTSPolygonOperation.getArgs() |
Modifier and Type | Method and Description |
---|---|
static <T extends org.locationtech.jts.geom.Geometry> |
JTSGeometryExpressions.asJTSGeometry(Expression<T> expr)
Create a new JTSGeometryExpression
|
static JTSGeometryExpression<?> |
JTSGeometryExpressions.collect(Expression<? extends org.locationtech.jts.geom.Geometry> expr1,
Expression<? extends org.locationtech.jts.geom.Geometry> expr2)
Return a specified ST_Geometry value from a collection of other geometries.
|
static JTSGeometryExpression<?> |
JTSGeometryExpressions.collect(Expression<? extends org.locationtech.jts.geom.Geometry> expr1,
Expression<? extends org.locationtech.jts.geom.Geometry> expr2)
Return a specified ST_Geometry value from a collection of other geometries.
|
static JTSGeometryExpression<?> |
JTSGeometryExpressions.collect(Expression<? extends org.locationtech.jts.geom.GeometryCollection> collection)
Return a specified ST_Geometry value from a collection of other geometries.
|
BooleanExpression |
JTSGeometryExpression.contains(Expression<? extends org.locationtech.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially contains” anotherGeometry.
|
BooleanExpression |
JTSGeometryExpression.crosses(Expression<? extends org.locationtech.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially crosses’ anotherGeometry.
|
JTSGeometryExpression<org.locationtech.jts.geom.Geometry> |
JTSGeometryExpression.difference(Expression<? extends org.locationtech.jts.geom.Geometry> geometry)
Returns a geometric object that represents the Point
set difference of this geometric object with anotherGeometry.
|
BooleanExpression |
JTSGeometryExpression.disjoint(Expression<? extends org.locationtech.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object is “spatially disjoint” from anotherGeometry.
|
NumberExpression<java.lang.Double> |
JTSGeometryExpression.distance(Expression<? extends org.locationtech.jts.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<java.lang.Double> |
JTSGeometryExpression.distanceSphere(Expression<? extends org.locationtech.jts.geom.Geometry> geometry) |
NumberExpression<java.lang.Double> |
JTSGeometryExpression.distanceSpheroid(Expression<? extends org.locationtech.jts.geom.Geometry> geometry) |
static BooleanExpression |
JTSGeometryExpressions.dwithin(Expression<? extends org.locationtech.jts.geom.Geometry> expr1,
Expression<? extends org.locationtech.jts.geom.Geometry> expr2,
double distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
JTSGeometryExpressions.dwithin(Expression<? extends org.locationtech.jts.geom.Geometry> expr1,
Expression<? extends org.locationtech.jts.geom.Geometry> expr2,
double distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
JTSGeometryExpressions.dwithin(Expression<? extends org.locationtech.jts.geom.Geometry> expr1,
Expression<? extends org.locationtech.jts.geom.Geometry> expr2,
Expression<java.lang.Double> distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
JTSGeometryExpressions.dwithin(Expression<? extends org.locationtech.jts.geom.Geometry> expr1,
Expression<? extends org.locationtech.jts.geom.Geometry> expr2,
Expression<java.lang.Double> distance)
Returns true if the geometries are within the specified distance of one another.
|
static BooleanExpression |
JTSGeometryExpressions.dwithin(Expression<? extends org.locationtech.jts.geom.Geometry> expr1,
Expression<? extends org.locationtech.jts.geom.Geometry> expr2,
Expression<java.lang.Double> distance)
Returns true if the geometries are within the specified distance of one another.
|
BooleanExpression |
JTSGeometryExpression.eq(Expression<? super T> right) |
static JTSGeometryExpression<?> |
JTSGeometryExpressions.extent(Expression<? extends org.locationtech.jts.geom.GeometryCollection> collection)
Returns the bounding box that bounds rows of geometries.
|
static JTSGeometryExpression<?> |
JTSGeometryExpressions.fromText(Expression<java.lang.String> text)
Return a specified ST_Geometry value from Well-Known Text representation (WKT).
|
static <T extends org.locationtech.jts.geom.Geometry> |
JTSGeometryExpressions.geometryOperation(java.lang.Class<? extends T> type,
Operator op,
Expression<?>... args)
Create a new Geometry operation expression
|
static JTSGeometryExpression<org.locationtech.jts.geom.Geometry> |
JTSGeometryExpressions.geometryOperation(Operator op,
Expression<?>... args)
Create a new Geometry operation expression
|
JTSGeometryExpression<org.locationtech.jts.geom.Geometry> |
JTSGeometryExpression.intersection(Expression<? extends org.locationtech.jts.geom.Geometry> geometry)
Returns a geometric object that represents the Point set intersection of this geometric
object with anotherGeometry.
|
BooleanExpression |
JTSGeometryExpression.intersects(Expression<? extends org.locationtech.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially intersects” anotherGeometry.
|
static JTSLineStringExpression<org.locationtech.jts.geom.LineString> |
JTSGeometryExpressions.lineStringOperation(Operator op,
Expression<?>... args)
Create a new LineString operation expression
|
BooleanExpression |
JTSGeometryExpression.overlaps(Expression<? extends org.locationtech.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially overlaps” anotherGeometry.
|
static JTSPointExpression<org.locationtech.jts.geom.Point> |
JTSGeometryExpressions.pointOperation(Operator op,
Expression<?>... args)
Create a new Point operation expression
|
static JTSPolygonExpression<org.locationtech.jts.geom.Polygon> |
JTSGeometryExpressions.polygonOperation(Operator op,
Expression<?>... args)
Create a new Polygon operation expression
|
BooleanExpression |
JTSGeometryExpression.relate(Expression<? extends org.locationtech.jts.geom.Geometry> geometry,
java.lang.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.locationtech.jts.geom.Geometry> |
JTSGeometryExpressions.setSRID(Expression<T> expr,
int srid)
Sets the SRID on a geometry to a particular integer value.
|
JTSGeometryExpression<org.locationtech.jts.geom.Geometry> |
JTSGeometryExpression.symDifference(Expression<? extends org.locationtech.jts.geom.Geometry> geometry)
Returns a geometric object that represents the
Point set symmetric difference of this geometric object with anotherGeometry.
|
BooleanExpression |
JTSGeometryExpression.touches(Expression<? extends org.locationtech.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object “spatially touches” anotherGeometry.
|
static <T extends org.locationtech.jts.geom.Geometry> |
JTSGeometryExpressions.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.locationtech.jts.geom.Geometry> |
JTSGeometryExpressions.translate(Expression<T> expr,
float deltax,
float deltay,
float deltaz)
Translates the geometry to a new location using the numeric parameters as offsets.
|
JTSGeometryExpression<org.locationtech.jts.geom.Geometry> |
JTSGeometryExpression.union(Expression<? extends org.locationtech.jts.geom.Geometry> geometry)
Returns a geometric object that represents the Point set
union of this geometric object with anotherGeometry.
|
BooleanExpression |
JTSGeometryExpression.within(Expression<? extends org.locationtech.jts.geom.Geometry> geometry)
Returns 1 (TRUE) if this geometric object is “spatially within” anotherGeometry.
|
Constructor and Description |
---|
JTSGeometryOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
JTSLineStringOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
JTSPointOperation(java.lang.Class<T> type,
Operator op,
java.util.List<Expression<?>> args) |
JTSPolygonOperation(java.lang.Class<? extends T> type,
Operator op,
java.util.List<Expression<?>> args) |
Modifier and Type | Interface and Description |
---|---|
interface |
RelationalPath<T>
RelationalPath extends
EntityPath to provide access to relational
metadata |
interface |
Union<RT>
Union defines an interface for Union queries |
Modifier and Type | Class and Description |
---|---|
class |
AbstractSQLQuery<T,Q extends AbstractSQLQuery<T,Q>>
AbstractSQLQuery is the base type for SQL query implementations |
class |
ProjectableSQLQuery<T,Q extends ProjectableSQLQuery<T,Q> & Query<Q>>
ProjectableSQLQuery is the base type for SQL query implementations |
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 |
SQLQuery<T>
SQLQuery is a JDBC based implementation of the SQLCommonQuery
interface |
class |
UnionImpl<T,Q extends ProjectableSQLQuery<T,Q> & Query<Q>>
Default implementation of the Union interface
|
class |
WindowFirstLast<T>
WindowFirstLast is a builder for window function expressions |
class |
WindowFunction<A>
WindowFunction is a builder for window function expressions |
class |
WindowOver<T>
WindowOver is the first part of a WindowFunction construction |
class |
WithinGroup<T>
WithinGroup is a builder for WITHIN GROUP constructs |
class |
WithinGroup.OrderBy
Intermediate step
|
Modifier and Type | Field and Description |
---|---|
static Expression<java.lang.Object[]> |
SQLExpressions.all
Wildcard expression
|
static Expression<java.lang.Long> |
SQLExpressions.countAll
Wildcard count expression
|
protected static Expression<?> |
SQLTemplates.FOR_SHARE |
protected static Expression<?> |
SQLTemplates.FOR_UPDATE |
protected static Expression<?> |
MySQLTemplates.LOCK_IN_SHARE_MODE |
protected static Expression<?> |
SQLTemplates.NO_WAIT |
protected static Expression<?> |
SQLSerializer.Q |
static Expression<?> |
SQLTemplates.RECURSIVE |
protected @Nullable Expression<?> |
ProjectableSQLQuery.union |
protected static Expression<?> |
SQLServerTemplates.WITH_REPEATABLE_READ |
Modifier and Type | Method and Description |
---|---|
Expression<RT> |
Union.as(Path<RT> alias)
Create an alias for the expression
|
Expression<T> |
UnionImpl.as(Path<T> alias) |
Expression<RT> |
Union.as(java.lang.String alias)
Create an alias for the expression
|
Expression<T> |
UnionImpl.as(java.lang.String alias) |
Expression<Tuple> |
PrimaryKey.getProjection() |
Expression<Tuple> |
ForeignKey.getProjection() |
static <T> Expression<T> |
SQLExpressions.set(Path<T> target,
Expression<? extends T> value)
Create an assignment expression
|
static <T> Expression<T> |
SQLExpressions.set(Path<T> target,
T value)
Create an assignment expression
|
Modifier and Type | Method and Description |
---|---|
java.util.List<Expression<?>> |
QBeans.getArgs() |
protected java.util.List<Expression<?>> |
SQLSerializer.getIdentifierColumns(java.util.List<JoinExpression> joins,
boolean alias)
Return a list of expressions that can be used to uniquely define the query sources
|
Modifier and Type | Method and Description |
---|---|
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 |
ProjectableSQLQuery.addFlag(QueryFlag.Position position,
java.lang.String prefix,
Expression<?> expr)
Add the given prefix and expression as a general query flag
|
Q |
SQLCommonQuery.addFlag(QueryFlag.Position position,
java.lang.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 java.lang.Number> |
SQLExpressions.avg(Expression<T> expr)
Start a window function expression
|
static WindowOver<java.lang.Double> |
SQLExpressions.corr(Expression<? extends java.lang.Number> expr1,
Expression<? extends java.lang.Number> expr2)
CORR returns the coefficient of correlation of a set of number pairs.
|
static WindowOver<java.lang.Double> |
SQLExpressions.corr(Expression<? extends java.lang.Number> expr1,
Expression<? extends java.lang.Number> expr2)
CORR returns the coefficient of correlation of a set of number pairs.
|
static WindowOver<java.lang.Long> |
SQLExpressions.count(Expression<?> expr)
Start a window function expression
|
static WindowOver<java.lang.Long> |
SQLExpressions.countDistinct(Expression<?> expr)
Start a window function expression
|
static WindowOver<java.lang.Double> |
SQLExpressions.covarPop(Expression<? extends java.lang.Number> expr1,
Expression<? extends java.lang.Number> expr2)
CORR returns the coefficient of correlation of a set of number pairs.
|
static WindowOver<java.lang.Double> |
SQLExpressions.covarPop(Expression<? extends java.lang.Number> expr1,
Expression<? extends java.lang.Number> expr2)
CORR returns the coefficient of correlation of a set of number pairs.
|
static WindowOver<java.lang.Double> |
SQLExpressions.covarSamp(Expression<? extends java.lang.Number> expr1,
Expression<? extends java.lang.Number> expr2)
CORR returns the coefficient of correlation of a set of number pairs.
|
static WindowOver<java.lang.Double> |
SQLExpressions.covarSamp(Expression<? extends java.lang.Number> expr1,
Expression<? extends java.lang.Number> expr2)
CORR returns the coefficient of correlation of a set of number pairs.
|
static WithinGroup<java.lang.Double> |
SQLExpressions.cumeDist(Expression<?>... args)
As an aggregate function, CUME_DIST calculates, for a hypothetical row r identified by the
arguments of the function and a corresponding sort specification, the relative position of row
r among the rows in the aggregation group.
|
static WithinGroup<java.lang.Long> |
SQLExpressions.denseRank(Expression<?>... args)
As an aggregate function, DENSE_RANK calculates the dense rank of a hypothetical row identified
by the arguments of the function with respect to a given sort specification.
|
BooleanExpression |
RelationalPathBase.eq(Expression<? super T> right)
Compares the two relational paths using primary key columns
|
BooleanExpression |
WindowFunction.eq(Expression<A> expr) |
static java.util.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<java.lang.Integer> expr) |
WindowFunction<A> |
WindowRows.BetweenAnd.following(Expression<java.lang.Integer> expr) |
Q |
SQLCommonQueryFactory.from(Expression<?>... from)
Create a new SELECT query
|
Q |
AbstractSQLQueryFactory.from(Expression<?>... args) |
Q |
ProjectableSQLQuery.from(Expression<?>... args) |
Q |
SQLCommonQuery.from(Expression<?>... o)
Defines the sources of the query
|
Q |
SQLCommonQueryFactory.from(Expression<?> from)
Create a new SELECT query
|
Q |
AbstractSQLQueryFactory.from(Expression<?> from) |
Q |
ProjectableSQLQuery.from(Expression<?> arg) |
java.sql.ResultSet |
AbstractSQLQuery.getResults(Expression<?>... exprs)
Deprecated.
Use @{code select(..)} to define the projection and
getResults() to obtain
the result set |
Union<RT> |
Union.groupBy(Expression<?>... o)
Defines the grouping/aggregation expressions
|
Union<T> |
UnionImpl.groupBy(Expression<?>... o) |
static StringExpression |
SQLExpressions.groupConcat(Expression<java.lang.String> expr)
Get a group_concat(expr) expression
|
static StringExpression |
SQLExpressions.groupConcat(Expression<java.lang.String> expr,
java.lang.String separator)
Get a group_concat(expr, separator) expression
|
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<java.lang.String> lhs,
Expression<java.lang.Integer> rhs)
Get the rhs leftmost characters of lhs
|
static StringExpression |
SQLExpressions.left(Expression<java.lang.String> lhs,
Expression<java.lang.Integer> rhs)
Get the rhs leftmost characters of lhs
|
static StringExpression |
SQLExpressions.left(Expression<java.lang.String> lhs,
int rhs)
Get the rhs leftmost characters of lhs
|
static WithinGroup<java.lang.Object> |
SQLExpressions.listagg(Expression<?> expr,
java.lang.String delimiter)
LISTAGG orders data within each group specified in the ORDER BY clause and then concatenates
the values of the measure column.
|
static <T extends java.lang.Comparable> |
SQLExpressions.max(Expression<T> expr)
Start a window function expression
|
static <T extends java.lang.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> expr,
Expression<? extends java.lang.Number> n)
NTH_VALUE returns the expr value of the nth row in the window defined by the analytic clause.
|
static <T> WindowOver<T> |
SQLExpressions.nthValue(Expression<T> expr,
Expression<? extends java.lang.Number> n)
NTH_VALUE returns the expr value of the nth row in the window defined by the analytic clause.
|
static <T> WindowOver<T> |
SQLExpressions.nthValue(Expression<T> expr,
java.lang.Number n)
NTH_VALUE returns the expr value of the nth row in the window defined by the analytic clause.
|
WindowFunction<A> |
WindowFunction.partitionBy(Expression<?>... partitionBy) |
WindowFunction<A> |
WindowFunction.partitionBy(Expression<?> partitionBy) |
static <T extends java.lang.Number> |
SQLExpressions.percentileCont(Expression<T> arg)
Calculates a percentile based on a continuous distribution of the column value
|
static <T extends java.lang.Number> |
SQLExpressions.percentileDisc(Expression<T> arg)
PERCENTILE_DISC is an inverse distribution function that assumes a discrete distribution model.
|
static WithinGroup<java.lang.Double> |
SQLExpressions.percentRank(Expression<?>... args)
As an aggregate function, PERCENT_RANK calculates, for a hypothetical row r identified by the
arguments of the function and a corresponding sort specification, the rank of row r minus 1
divided by the number of rows in the aggregate group.
|
WindowFunction<A> |
WindowRows.preceding(Expression<java.lang.Integer> expr) |
WindowRows.BetweenAnd |
WindowRows.Between.preceding(Expression<java.lang.Integer> expr) |
WindowFunction<A> |
WindowRows.BetweenAnd.preceding(Expression<java.lang.Integer> expr) |
static WithinGroup<java.lang.Long> |
SQLExpressions.rank(Expression<?>... args)
As an aggregate function, RANK calculates the rank of a hypothetical row identified by the
arguments of the function with respect to a given sort specification.
|
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<java.lang.Double> |
SQLExpressions.regrAvgx(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_AVGX evaluates the average of the independent variable (arg2) of the regression line.
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrAvgx(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_AVGX evaluates the average of the independent variable (arg2) of the regression line.
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrAvgy(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_AVGY evaluates the average of the dependent variable (arg1) of the regression line.
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrAvgy(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_AVGY evaluates the average of the dependent variable (arg1) of the regression line.
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrCount(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_COUNT returns an integer that is the number of non-null number pairs used to fit the regression line.
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrCount(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_COUNT returns an integer that is the number of non-null number pairs used to fit the regression line.
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrIntercept(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_INTERCEPT returns the y-intercept of the regression line.
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrIntercept(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_INTERCEPT returns the y-intercept of the regression line.
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrR2(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_R2 returns the coefficient of determination (also called R-squared or goodness of fit) for the regression.
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrR2(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_R2 returns the coefficient of determination (also called R-squared or goodness of fit) for the regression.
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrSlope(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_SLOPE returns the slope of the line
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrSlope(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_SLOPE returns the slope of the line
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrSxx(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_SXX makes the following computation after the elimination of null (arg1, arg2) pairs:
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrSxx(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_SXX makes the following computation after the elimination of null (arg1, arg2) pairs:
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrSxy(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_SXY makes the following computation after the elimination of null (arg1, arg2) pairs:
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrSxy(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_SXY makes the following computation after the elimination of null (arg1, arg2) pairs:
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrSyy(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_SYY makes the following computation after the elimination of null (arg1, arg2) pairs:
|
static WindowOver<java.lang.Double> |
SQLExpressions.regrSyy(Expression<? extends java.lang.Number> arg1,
Expression<? extends java.lang.Number> arg2)
REGR_SYY makes the following computation after the elimination of null (arg1, arg2) pairs:
|
static StringExpression |
SQLExpressions.right(Expression<java.lang.String> lhs,
Expression<java.lang.Integer> rhs)
Get the rhs leftmost characters of lhs
|
static StringExpression |
SQLExpressions.right(Expression<java.lang.String> lhs,
Expression<java.lang.Integer> rhs)
Get the rhs leftmost characters of lhs
|
static StringExpression |
SQLExpressions.right(Expression<java.lang.String> lhs,
int rhs)
Get the rhs rightmost characters of lhs
|
SQLQuery<Tuple> |
SQLQuery.select(Expression<?>... exprs) |
abstract AbstractSQLQuery<Tuple,?> |
AbstractSQLQueryFactory.select(Expression<?>... exprs)
Create a new SQL query with the given projection
|
SQLQuery<Tuple> |
SQLQueryFactory.select(Expression<?>... exprs) |
static SQLQuery<Tuple> |
SQLExpressions.select(Expression<?>... exprs)
Create a new detached SQLQuery instance with the given projection
|
abstract <T> AbstractSQLQuery<T,?> |
AbstractSQLQueryFactory.select(Expression<T> expr)
Create a new SQL query with the given projection
|
<T> SQLQuery<T> |
SQLQueryFactory.select(Expression<T> expr) |
static <T> SQLQuery<T> |
SQLExpressions.select(Expression<T> expr)
Create a new detached SQLQuery instance with the given projection
|
<U> SQLQuery<U> |
SQLQuery.select(Expression<U> expr) |
abstract AbstractSQLQuery<Tuple,?> |
AbstractSQLQueryFactory.selectDistinct(Expression<?>... exprs)
Create a new SQL query with the given projection
|
SQLQuery<Tuple> |
SQLQueryFactory.selectDistinct(Expression<?>... exprs) |
static SQLQuery<Tuple> |
SQLExpressions.selectDistinct(Expression<?>... exprs)
Create a new detached SQLQuery instance with the given projection
|
abstract <T> AbstractSQLQuery<T,?> |
AbstractSQLQueryFactory.selectDistinct(Expression<T> expr)
Create a new SQL query with the given projection
|
<T> SQLQuery<T> |
SQLQueryFactory.selectDistinct(Expression<T> expr) |
static <T> SQLQuery<T> |
SQLExpressions.selectDistinct(Expression<T> expr)
Create a new detached SQLQuery instance with the given projection
|
void |
SQLSerializer.serializeUnion(Expression<?> union,
QueryMetadata metadata,
boolean unionAll) |
static <T> Expression<T> |
SQLExpressions.set(Path<T> target,
Expression<? extends T> value)
Create an assignment expression
|
static <T extends java.lang.Number> |
SQLExpressions.stddev(Expression<T> expr)
returns the sample standard deviation of expr, a set of numbers.
|
static <T extends java.lang.Number> |
SQLExpressions.stddevDistinct(Expression<T> expr)
returns the sample standard deviation of expr, a set of numbers.
|
static <T extends java.lang.Number> |
SQLExpressions.stddevPop(Expression<T> expr)
returns the population standard deviation and returns the square root of the population variance.
|
static <T extends java.lang.Number> |
SQLExpressions.stddevSamp(Expression<T> expr)
returns the cumulative sample standard deviation and returns the square root of the sample variance.
|
static <T extends java.lang.Number> |
SQLExpressions.sum(Expression<T> expr)
Start a window function expression
|
static <T extends java.lang.Number> |
SQLExpressions.variance(Expression<T> expr)
returns the variance of expr
|
static <T extends java.lang.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 java.lang.Number> |
SQLExpressions.varSamp(Expression<T> expr)
returns the sample variance of a set of numbers after discarding the nulls in this set.
|
Q |
ProjectableSQLQuery.with(Path<?> alias,
Expression<?> query) |
Q |
SQLCommonQuery.with(Path<?> alias,
Expression<?> query)
Adds a common table expression
|
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 |
---|---|
SQLSerializer |
SQLSerializer.handleSelect(java.lang.String sep,
java.util.List<? extends Expression<?>> expressions) |
void |
SQLListeners.notifyInsert(RelationalPath<?> entity,
QueryMetadata md,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLBaseListener.notifyInsert(RelationalPath<?> entity,
QueryMetadata md,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLListener.notifyInsert(RelationalPath<?> entity,
QueryMetadata md,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
SubQueryExpression<?> subQuery)
Notify about an insertion
|
void |
SQLListeners.notifyMerge(RelationalPath<?> entity,
QueryMetadata md,
java.util.List<Path<?>> keys,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLBaseListener.notifyMerge(RelationalPath<?> entity,
QueryMetadata md,
java.util.List<Path<?>> keys,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLListener.notifyMerge(RelationalPath<?> entity,
QueryMetadata md,
java.util.List<Path<?>> keys,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
SubQueryExpression<?> subQuery)
Notify about a merge
|
void |
SQLListeners.notifyUpdate(RelationalPath<?> entity,
QueryMetadata md,
java.util.Map<Path<?>,Expression<?>> updates) |
void |
SQLBaseListener.notifyUpdate(RelationalPath<?> entity,
QueryMetadata md,
java.util.Map<Path<?>,Expression<?>> updates) |
void |
SQLListener.notifyUpdate(RelationalPath<?> entity,
QueryMetadata md,
java.util.Map<Path<?>,Expression<?>> updates)
Notify about an update operation
|
protected void |
SQLSerializer.serializeForInsert(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
@Nullable SubQueryExpression<?> subQuery) |
protected void |
SQLSerializer.serializeForMerge(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.List<Path<?>> keys,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
@Nullable SubQueryExpression<?> subQuery) |
protected void |
SQLSerializer.serializeForUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.Map<Path<?>,Expression<?>> updates) |
void |
SQLSerializer.serializeInsert(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
@Nullable SubQueryExpression<?> subQuery) |
void |
SQLTemplates.serializeInsert(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
SubQueryExpression<?> subQuery,
SQLSerializer context)
template method for INSERT serialization
|
void |
SQLSerializer.serializeMerge(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.List<Path<?>> keys,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
@Nullable SubQueryExpression<?> subQuery) |
void |
SQLTemplates.serializeMerge(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.List<Path<?>> keys,
java.util.List<Path<?>> columns,
java.util.List<Expression<?>> values,
SubQueryExpression<?> subQuery,
SQLSerializer context)
template method for MERGE serialization
|
void |
SQLSerializer.serializeUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.Map<Path<?>,Expression<?>> updates) |
void |
SQLServer2012Templates.serializeUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.Map<Path<?>,Expression<?>> updates,
SQLSerializer context) |
void |
SQLServer2005Templates.serializeUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.Map<Path<?>,Expression<?>> updates,
SQLSerializer context) |
void |
SQLTemplates.serializeUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.Map<Path<?>,Expression<?>> updates,
SQLSerializer context)
template method for UPDATE serialization
|
void |
OracleTemplates.serializeUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
java.util.Map<Path<?>,Expression<?>> updates,
SQLSerializer context) |
protected void |
SQLSerializer.visitOperation(java.lang.Class<?> type,
Operator operator,
java.util.List<? extends Expression<?>> args) |
Constructor and Description |
---|
WindowFunction(Expression<A> expr) |
WindowOver(java.lang.Class<? extends T> type,
Operator op,
Expression<?> arg) |
WindowOver(java.lang.Class<? extends T> type,
Operator op,
Expression<?> arg1,
Expression<?> arg2) |
WindowOver(java.lang.Class<? extends T> type,
Operator op,
Expression<?> arg1,
Expression<?> arg2) |
WithBuilder(QueryMixin<R> queryMixin,
Expression<?> alias) |
WithinGroup(java.lang.Class<? extends T> type,
Operator op,
Expression<?>... args) |
WithinGroup(java.lang.Class<? extends T> type,
Operator op,
Expression<?> arg) |
WithinGroup(java.lang.Class<? extends T> type,
Operator op,
Expression<?> arg1,
Expression<?> arg2) |
WithinGroup(java.lang.Class<? extends T> type,
Operator op,
Expression<?> arg1,
Expression<?> arg2) |
Modifier and Type | Field and Description |
---|---|
protected java.util.Map<Path<?>,Expression<?>> |
AbstractSQLUpdateClause.updates |
protected java.util.List<Expression<?>> |
AbstractSQLInsertClause.values |
protected java.util.List<Expression<?>> |
SQLMergeClause.values |
Modifier and Type | Method and Description |
---|---|
java.util.Map<Path<?>,Expression<?>> |
SQLUpdateBatch.getUpdates() |
java.util.List<Expression<?>> |
SQLMergeBatch.getValues() |
java.util.List<Expression<?>> |
SQLInsertBatch.getValues() |
Modifier and Type | Method and Description |
---|---|
C |
AbstractSQLUpdateClause.addFlag(QueryFlag.Position position,
Expression<?> flag)
Add the given Expression at the given position as a query flag
|
C |
AbstractSQLInsertClause.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
|
C |
AbstractSQLDeleteClause.addFlag(QueryFlag.Position position,
Expression<?> flag)
Add the given Expression at the given position as a query flag
|
<T> C |
AbstractSQLUpdateClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> C |
AbstractSQLInsertClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> SQLMergeClause |
SQLMergeClause.set(Path<T> path,
Expression<? extends T> expression) |
Constructor and Description |
---|
SQLInsertBatch(java.util.List<Path<?>> c,
java.util.List<Expression<?>> v,
@Nullable SubQueryExpression<?> sq) |
SQLMergeBatch(java.util.List<Path<?>> k,
java.util.List<Path<?>> c,
java.util.List<Expression<?>> v,
@Nullable SubQueryExpression<?> sq) |
SQLUpdateBatch(QueryMetadata metadata,
java.util.Map<Path<?>,Expression<?>> updates) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractSQLServerQuery<T,C extends AbstractSQLServerQuery<T,C>>
AbstractSQLServerQuery provides SQL Server related extensions to SQLQuery |
class |
SQLServerQuery<T>
SQLServerQuery provides SQL Server related extensions to SQLQuery
If you need to subtype this, use the base class instead. |
Modifier and Type | Method and Description |
---|---|
SQLServerQuery<Tuple> |
SQLServerQueryFactory.select(Expression<?>... exprs) |
SQLServerQuery<Tuple> |
SQLServerQuery.select(Expression<?>... exprs) |
<T> SQLServerQuery<T> |
SQLServerQueryFactory.select(Expression<T> expr) |
<U> SQLServerQuery<U> |
SQLServerQuery.select(Expression<U> expr) |
SQLServerQuery<Tuple> |
SQLServerQueryFactory.selectDistinct(Expression<?>... exprs) |
<T> SQLServerQuery<T> |
SQLServerQueryFactory.selectDistinct(Expression<T> expr) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractMySQLQuery<T,C extends AbstractMySQLQuery<T,C>>
MySQLQuery provides MySQL related extensions to SQLQuery. |
class |
MySQLQuery<T>
MySQLQuery provides MySQL related extensions to SQLQuery. |
Modifier and Type | Method and Description |
---|---|
SQLInsertClause |
MySQLQueryFactory.insertOnDuplicateKeyUpdate(RelationalPath<?> entity,
Expression<?>... clauses)
Create a INSERT ...
|
SQLInsertClause |
MySQLQueryFactory.insertOnDuplicateKeyUpdate(RelationalPath<?> entity,
Expression<?> clause)
Create a INSERT ...
|
MySQLQuery<Tuple> |
MySQLQuery.select(Expression<?>... exprs) |
MySQLQuery<Tuple> |
MySQLQueryFactory.select(Expression<?>... exprs) |
<T> MySQLQuery<T> |
MySQLQueryFactory.select(Expression<T> expr) |
<U> MySQLQuery<U> |
MySQLQuery.select(Expression<U> expr) |
MySQLQuery<Tuple> |
MySQLQueryFactory.selectDistinct(Expression<?>... exprs) |
<T> MySQLQuery<T> |
MySQLQueryFactory.selectDistinct(Expression<T> expr) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractOracleQuery<T,C extends AbstractOracleQuery<T,C>>
OracleQuery provides Oracle specific extensions to the base SQL query type |
class |
OracleQuery<T>
OracleQuery provides Oracle specific extensions to the base SQL query type
If you need to subtype this, use the base class instead. |
Modifier and Type | Method and Description |
---|---|
C |
AbstractOracleQuery.orderSiblingsBy(Expression<?> path)
ORDER SIBLINGS BY preserves any ordering specified in the hierarchical query clause and then
applies the order_by_clause to the siblings of the hierarchy.
|
OracleQuery<Tuple> |
OracleQuery.select(Expression<?>... exprs) |
OracleQuery<Tuple> |
OracleQueryFactory.select(Expression<?>... exprs) |
<T> OracleQuery<T> |
OracleQueryFactory.select(Expression<T> expr) |
<U> OracleQuery<U> |
OracleQuery.select(Expression<U> expr) |
OracleQuery<Tuple> |
OracleQueryFactory.selectDistinct(Expression<?>... exprs) |
<T> OracleQuery<T> |
OracleQueryFactory.selectDistinct(Expression<T> expr) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractPostgreSQLQuery<T,C extends AbstractPostgreSQLQuery<T,C>>
PostgreSQLQuery provides PostgreSQL related extensions to SQLQuery |
class |
PostgreSQLQuery<T>
PostgreSQLQuery provides Postgres related extensions to SQLQuery. |
Modifier and Type | Method and Description |
---|---|
C |
AbstractPostgreSQLQuery.distinctOn(Expression<?>... exprs)
adds a DISTINCT ON clause
|
PostgreSQLQuery<Tuple> |
PostgreSQLQueryFactory.select(Expression<?>... exprs) |
PostgreSQLQuery<Tuple> |
PostgreSQLQuery.select(Expression<?>... exprs) |
<T> PostgreSQLQuery<T> |
PostgreSQLQueryFactory.select(Expression<T> expr) |
<U> PostgreSQLQuery<U> |
PostgreSQLQuery.select(Expression<U> expr) |
PostgreSQLQuery<Tuple> |
PostgreSQLQueryFactory.selectDistinct(Expression<?>... exprs) |
<T> PostgreSQLQuery<T> |
PostgreSQLQueryFactory.selectDistinct(Expression<T> expr) |
Modifier and Type | Class and Description |
---|---|
class |
QSpatialRefSys
QSpatialRefSys is a Querydsl query type for SpatialRefSys
|
class |
RelationalPathSpatial<T>
RelationalPathSpatial extends RelationalPathBase to provide factory methods
for spatial path creation |
Modifier and Type | Class and Description |
---|---|
class |
AbstractTeradataQuery<T,C extends AbstractTeradataQuery<T,C>>
AbstractTeradataQuery provides Teradata related extensions to SQLQuery |
class |
TeradataQuery<T>
TeradataQuery provides Teradata related extensions to SQLQuery
If you need to subtype this, use the base class instead. |
Modifier and Type | Method and Description |
---|---|
TeradataQuery<Tuple> |
TeradataQueryFactory.select(Expression<?>... exprs) |
TeradataQuery<Tuple> |
TeradataQuery.select(Expression<?>... exprs) |
<T> TeradataQuery<T> |
TeradataQueryFactory.select(Expression<T> expr) |
<U> TeradataQuery<U> |
TeradataQuery.select(Expression<U> expr) |
TeradataQuery<Tuple> |
TeradataQueryFactory.selectDistinct(Expression<?>... exprs) |
<T> TeradataQuery<T> |
TeradataQueryFactory.selectDistinct(Expression<T> expr) |
Copyright © 2007–2021 Querydsl. All rights reserved.