Package | Description |
---|---|
com.mysema.query.alias |
Alias functionality
|
com.mysema.query.lucene | |
com.mysema.query.mongodb | |
com.mysema.query.sql |
SQL/JDBC support for Querydsl
|
com.mysema.query.support |
Various support classes
|
com.mysema.query.types.expr |
Operations represent typed operations with operator and arguments
|
com.mysema.query.types.path |
Paths represent typed property paths, variables and list-map-array access
|
com.mysema.query.types.query |
Subquery implementations
|
com.mysema.query.types.template |
Custom types are comparable to operations but contain the serialization
templates instead of operator patterns.
|
Modifier and Type | Method and Description |
---|---|
static <D> CollectionPath<D,SimpleExpression<D>> |
Alias.$(Collection<D> args) |
static <D> ListPath<D,SimpleExpression<D>> |
Alias.$(List<D> args) |
static <K,V> MapPath<K,V,SimpleExpression<V>> |
Alias.$(Map<K,V> args) |
static <D> SetPath<D,SimpleExpression<D>> |
Alias.$(Set<D> args) |
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 | Class and Description |
---|---|
class |
Point
Point is an adapter type for Double[] arrays to use geo spatial querying features of Mongodb
|
Modifier and Type | Class and Description |
---|---|
class |
RelationalFunctionCall<T>
Represents a table valued function call
|
class |
RelationalPathBase<T>
RelationalPathBase is a base class for
RelationalPath implementations |
class |
WindowOver<T>
WindowOver is the first part of a WindowFunction construction
|
Modifier and Type | Method and Description |
---|---|
SimpleExpression<A> |
WindowFunction.as(Expression<A> alias) |
SimpleExpression<A> |
WindowFunction.getValue() |
static <T extends Number> |
SQLExpressions.nextval(Class<T> type,
String sequence)
Get a nextval(sequence) expression of the given type
|
static SimpleExpression<Long> |
SQLExpressions.nextval(String sequence)
Get a nextval(sequence) expression
|
<T> SimpleExpression<T> |
SQLSubQuery.union(List<? extends SubQueryExpression<T>> sq) |
<T> SimpleExpression<T> |
SQLSubQuery.union(SubQueryExpression<T>... sq) |
<T> SimpleExpression<T> |
SQLSubQuery.unionAll(List<? extends SubQueryExpression<T>> sq) |
<T> SimpleExpression<T> |
SQLSubQuery.unionAll(SubQueryExpression<T>... sq) |
Modifier and Type | Method and Description |
---|---|
static <D> SimpleExpression<D> |
Expressions.as(Expression<D> source,
Path<D> alias) |
static <D> SimpleExpression<D> |
Expressions.as(Expression<D> source,
String alias)
Create the alias expression source as alias
|
static <D> SimpleExpression<D> |
Expressions.constantAs(D source,
Path<D> alias)
Get the alias expression source as alias
|
static <T> SimpleExpression<T> |
Expressions.list(Class<T> clazz,
SimpleExpression<?>... exprs)
Combine the given expressions into a list expression
|
static SimpleExpression<Tuple> |
Expressions.list(SimpleExpression<?>... exprs)
Combine the given expressions into a list expression
|
static <T> SimpleExpression<T> |
Expressions.operation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
Create a new Operation expression
|
static <T> SimpleExpression<T> |
Expressions.template(Class<T> cl,
String template,
Object... args)
Create a new Template expression
|
static <T> SimpleExpression<T> |
Expressions.template(Class<T> cl,
Template template,
Object... args)
Create a new Template expression
|
Modifier and Type | Method and Description |
---|---|
static <T> SimpleExpression<T> |
Expressions.list(Class<T> clazz,
SimpleExpression<?>... exprs)
Combine the given expressions into a list expression
|
static SimpleExpression<Tuple> |
Expressions.list(SimpleExpression<?>... exprs)
Combine the given expressions into a list expression
|
Modifier and Type | Interface and Description |
---|---|
interface |
ListExpression<E,Q extends SimpleExpression<? super E>>
ListExpression represents
List typed expressions |
class |
MapExpressionBase<K,V,Q extends SimpleExpression<? super V>>
MapExpressionBase is an abstract base class for
MapExpression implementations |
Modifier and Type | Class and Description |
---|---|
class |
BooleanExpression
BooleanExpression represents
Boolean expressions |
class |
BooleanOperation
BooleanOperation represents boolean operations
|
class |
ComparableExpression<T extends Comparable>
ComparableExpression extends
ComparableExpressionBase to provide comparison methods. |
class |
ComparableExpressionBase<T extends Comparable>
ComparableExpressionBase represents comparable expressions
|
class |
ComparableOperation<T extends Comparable<?>>
ComparableOperation represents Comparable operations
|
class |
DateExpression<T extends Comparable>
DateExpression represents Date expressions
The date representation is compatible with the Gregorian calendar.
|
class |
DateOperation<T extends Comparable<?>>
DateOperation represents Date operations
|
class |
DateTimeExpression<T extends Comparable>
DateTimeExpression represents Date / Time expressions
The date representation is compatible with the Gregorian calendar.
|
class |
DateTimeOperation<T extends Comparable<?>>
DateTimeOperation represents DateTime operations
|
class |
EnumExpression<T extends Enum<T>>
EnumExpression represents Enum typed expressions
|
class |
EnumOperation<T extends Enum<T>>
EnumOperation represents enum operations
|
class |
NumberExpression<T extends Number & Comparable<?>>
NumberExpression represents a numeric expression
|
class |
NumberOperation<T extends Number & Comparable<?>>
NumberOperation represents numeric operations
|
class |
Param<T>
Param defines a parameter in a query with an optional name
|
class |
SimpleOperation<T>
SimpleOperation represents a simple operation expression
|
class |
StringExpression
StringExpression represents
String expressions |
class |
StringOperation
StringOperation represents a String typed operation
|
class |
TemporalExpression<T extends Comparable>
TemporalExpression is a supertype for Date/Time related types
|
class |
TimeExpression<T extends Comparable>
TimeExpression represents Time expressions
|
class |
TimeOperation<T extends Comparable<?>>
TimeOperation represents Time operations
|
Modifier and Type | Method and Description |
---|---|
SimpleExpression<T> |
SimpleExpression.as(Path<T> alias)
Create an alias for the expression
|
SimpleExpression<T> |
SimpleExpression.as(String alias)
Create an alias for the expression
|
SimpleExpression<Character> |
StringExpression.charAt(Expression<Integer> i)
Get the character at the given index
|
SimpleExpression<Character> |
StringExpression.charAt(int i)
Get the character at the given index
|
static <D> SimpleExpression<D> |
SimpleOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args) |
static <D> SimpleExpression<D> |
SimpleOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one) |
static <D> SimpleExpression<D> |
SimpleOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?> one,
Expression<?> two) |
SimpleExpression<T> |
ArrayExpression.get(Expression<Integer> index)
Get the element at the given index
|
SimpleExpression<T> |
ArrayExpression.get(int index)
Get the element at the given index
|
SimpleExpression<T> |
SimpleExpression.nullif(Expression<T> other)
Get a
nullif(this, other) expression |
SimpleExpression<T> |
SimpleExpression.nullif(T other)
Get a
nullif(this, other) expression |
Modifier and Type | Class and Description |
---|---|
class |
CollectionPath<E,Q extends SimpleExpression<? super E>>
CollectionPath represents collection paths
|
class |
CollectionPathBase<C extends Collection<E>,E,Q extends SimpleExpression<? super E>>
CollectionPath is a base class for collection typed paths
|
class |
ListPath<E,Q extends SimpleExpression<? super E>>
ListPath represents list paths
|
class |
MapPath<K,V,E extends SimpleExpression<? super V>>
MapPath represents map paths
|
class |
SetPath<E,Q extends SimpleExpression<? super E>>
SetPath represents set paths
|
Modifier and Type | Class and Description |
---|---|
class |
ArrayPath<A,E>
ArrayPath represents an array typed path
|
class |
BeanPath<T>
BeanPath represents bean paths
|
class |
BooleanPath
BooleanPath represents boolean path expressions
|
class |
ComparableEntityPath<T extends Comparable>
ComparableEntityPath extends the ComparablePath class to implement the EntityPath interface
|
class |
ComparablePath<T extends Comparable>
ComparablePath represents Comparable paths
|
class |
DatePath<T extends Comparable>
DatePath presents Date paths
|
class |
DateTimePath<T extends Comparable>
DateTimePath presents DateTime typed paths
|
class |
EntityPathBase<T>
EntityPathBase provides a base class for EntityPath implementations
|
class |
EnumPath<T extends Enum<T>>
EnumPath represents enum paths
|
class |
NumberPath<T extends Number & Comparable<?>>
NumberPath represents numeric paths
|
class |
PathBuilder<T>
PathBuilder is an extension to EntityPathBase for dynamic path construction
|
class |
SimplePath<T>
SimplePath represents simple paths
|
class |
StringPath
StringPath represents String typed paths
|
class |
TimePath<T extends Comparable>
TimePath represented Time paths
|
Modifier and Type | Method and Description |
---|---|
protected <A,Q extends SimpleExpression<? super A>> |
BeanPath.createCollection(String property,
Class<? super A> type,
Class<? super Q> queryType,
PathInits inits)
Create a new Collection typed path
|
protected <A,E extends SimpleExpression<? super A>> |
BeanPath.createList(String property,
Class<? super A> type,
Class<? super E> queryType,
PathInits inits)
Create a new List typed path
|
protected <K,V,E extends SimpleExpression<? super V>> |
BeanPath.createMap(String property,
Class<? super K> key,
Class<? super V> value,
Class<? super E> queryType)
Create a new Map typed path
|
protected <A,E extends SimpleExpression<? super A>> |
BeanPath.createSet(String property,
Class<? super A> type,
Class<? super E> queryType,
PathInits inits)
Create a new Set typed path
|
<A,E extends SimpleExpression<A>> |
PathBuilder.getCollection(String property,
Class<A> type,
Class<E> queryType)
Get a new Collection typed path
|
<A,E extends SimpleExpression<A>> |
PathBuilder.getList(String property,
Class<A> type,
Class<E> queryType)
Get a new List typed path
|
<K,V,E extends SimpleExpression<V>> |
PathBuilder.getMap(String property,
Class<K> key,
Class<V> value,
Class<E> queryType)
Get a new Map typed path
|
<A,E extends SimpleExpression<A>> |
PathBuilder.getSet(String property,
Class<A> type,
Class<E> queryType)
Get a new Set typed path
|
Modifier and Type | Class and Description |
---|---|
class |
BooleanSubQuery
Boolean typed single result subquery
|
class |
ComparableSubQuery<T extends Comparable<?>>
Comparable typed single result subquery
|
class |
DateSubQuery<T extends Comparable<?>>
Date typed single result subquery
|
class |
DateTimeSubQuery<T extends Comparable<?>>
DateTime typed single result subquery
|
class |
NumberSubQuery<T extends Number & Comparable<?>>
Number typed single result subquery
|
class |
StringSubQuery
String typed single result subquery
|
class |
TimeSubQuery<T extends Comparable<?>>
Time typed single result subquery
|
Modifier and Type | Method and Description |
---|---|
SimpleExpression<?> |
ListSubQuery.as(Expression<?> alias) |
Modifier and Type | Class and Description |
---|---|
class |
BooleanTemplate
BooleanTemplate is a custom boolean expression
|
class |
ComparableTemplate<T extends Comparable<?>>
ComparableTemplate defines custom comparable expressions
|
class |
DateTemplate<T extends Comparable<?>>
DateTemplate defines custom date expressions
|
class |
DateTimeTemplate<T extends Comparable<?>>
DateTimeTemplate defines custom dateTime expressions
|
class |
EnumTemplate<T extends Enum<T>>
EnumTemplate defines custom enum expressions
|
class |
NumberTemplate<T extends Number & Comparable<?>>
NumberTemplate defines custom numeric expressions
|
class |
SimpleTemplate<T>
SimpleTemplate defines custom simple expressions
|
class |
StringTemplate
StringTemplate defines custom String expressions
|
class |
TimeTemplate<T extends Comparable<?>>
TimeTemplate defines custom time expressions
|
Modifier and Type | Method and Description |
---|---|
static <T> SimpleExpression<T> |
SimpleTemplate.create(Class<? extends T> type,
String template) |
static <T> SimpleExpression<T> |
SimpleTemplate.create(Class<? extends T> type,
String template,
Object... args) |
static <T> SimpleExpression<T> |
SimpleTemplate.create(Class<? extends T> type,
String template,
Object one) |
static <T> SimpleExpression<T> |
SimpleTemplate.create(Class<? extends T> type,
String template,
Object one,
Object two) |
static <T> SimpleExpression<T> |
SimpleTemplate.create(Class<? extends T> type,
Template template,
Object... args) |
Copyright © 2007-2013 Mysema Ltd. All Rights Reserved.