|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use SimpleExpression | |
---|---|
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.sql.oracle | Oracle support for Querydsl SQL |
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. |
Uses of SimpleExpression in com.mysema.query.alias |
---|
Methods in com.mysema.query.alias with type parameters of type SimpleExpression | ||
---|---|---|
static
|
Alias.$(Collection<D> args)
|
|
static
|
Alias.$(List<D> args)
|
|
static
|
Alias.$(Map<K,V> args)
|
|
static
|
Alias.$(Set<D> args)
|
Uses of SimpleExpression in com.mysema.query.lucene |
---|
Subclasses of SimpleExpression in com.mysema.query.lucene | |
---|---|
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 |
Uses of SimpleExpression in com.mysema.query.mongodb |
---|
Subclasses of SimpleExpression in com.mysema.query.mongodb | |
---|---|
class |
Point
Point is an adapter type for Double[] arrays to use geo spatial querying features of Mongodb |
Uses of SimpleExpression in com.mysema.query.sql |
---|
Subclasses of SimpleExpression in com.mysema.query.sql | |
---|---|
class |
RelationalPathBase<T>
RelationalPathBase is a base class for RelationPath implements |
Uses of SimpleExpression in com.mysema.query.sql.oracle |
---|
Subclasses of SimpleExpression in com.mysema.query.sql.oracle | |
---|---|
class |
SumOver<A extends Number & Comparable<? super A>>
SumOver is a fluent type for Oracle specific sum over / partition by / order by constructs |
Uses of SimpleExpression in com.mysema.query.support |
---|
Methods in com.mysema.query.support that return SimpleExpression | ||
---|---|---|
static
|
Expressions.operation(Class<T> type,
Operator<? super T> operator,
Expression<?>... args)
|
|
static
|
Expressions.subQuery(Class<T> type,
QueryMetadata metadata)
|
|
static
|
Expressions.template(Class<T> cl,
String template,
Expression<?>... args)
|
Uses of SimpleExpression in com.mysema.query.types.expr |
---|
Classes in com.mysema.query.types.expr with type parameters of type SimpleExpression | |
---|---|
interface |
ListExpression<E,Q extends SimpleExpression<? super E>>
ListExpression represents java.util.List typed expressions |
class |
MapExpressionBase<K,V,Q extends SimpleExpression<? super V>>
MapExpressionBase is an abstract base class for MapExpression implementations |
Subclasses of SimpleExpression in com.mysema.query.types.expr | |
---|---|
class |
BooleanExpression
BooleanExpression represents boolean expressions |
class |
BooleanOperation
BooleanOperation represents boolean operations |
class |
Coalesce<T extends Comparable>
Coalesce defines a coalesce function invocation. |
class |
CollectionExpressionBase<T extends Collection<E>,E>
CollectionExpressionBase is an abstract base class for CollectionExpression implementations |
class |
ComparableExpression<T extends Comparable>
ComparableExpression extends ComparableExpressionBase to provide comparison methods. |
class |
ComparableExpressionBase<T extends Comparable>
ComparableExpressionBase represents comparable expressions |
class |
ComparableOperation<T extends Comparable<?>>
ComparableOperation represents Comparable operations |
class |
DateExpression<T extends Comparable>
DateExpression represents Date expressions The date representation is compatible with the Gregorian calendar. |
class |
DateOperation<T extends Comparable<?>>
DateOperation represents Date operations |
class |
DateTimeExpression<T extends Comparable>
DateTimeExpression represents Date / Time expressions The date representation is compatible with the Gregorian calendar. |
class |
DateTimeOperation<T extends Comparable<?>>
DateTimeOperation represents DateTime operations |
class |
EnumExpression<T extends Enum<T>>
EnumExpression represents Enum typed expressions |
class |
EnumOperation<T extends Enum<T>>
EnumOperation represents enum operations |
class |
MapExpressionBase<K,V,Q extends SimpleExpression<? super V>>
MapExpressionBase is an abstract base class for MapExpression implementations |
class |
NumberExpression<T extends Number & Comparable<?>>
NumberExpression represents a numeric expression |
class |
NumberOperation<T extends Number & Comparable<?>>
NumberOperation represents numeric operations |
class |
Param<T>
Param defines a parameter in a query with an optional name |
class |
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 |
Methods in com.mysema.query.types.expr that return SimpleExpression | ||
---|---|---|
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
|
SimpleOperation.create(Class<D> type,
Operator<? super D> op,
Expression<?>... args)
Factory method |
|
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<String[]> |
StringExpression.split(String regex)
Split the given String with regex as the matcher for the separator |
Uses of SimpleExpression in com.mysema.query.types.path |
---|
Classes in com.mysema.query.types.path with type parameters of type SimpleExpression | |
---|---|
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 |
Subclasses of SimpleExpression in com.mysema.query.types.path | |
---|---|
class |
ArrayPath<E>
ArrayPath represents an array typed path |
class |
BeanPath<T>
BeanPath represents bean paths |
class |
BooleanPath
BooleanPath represents boolean path expressions |
class |
CollectionPath<E,Q extends SimpleExpression<? super E>>
CollectionPath represents collection paths |
class |
CollectionPathBase<C extends Collection<E>,E,Q extends SimpleExpression<? super E>>
CollectionPath is a base class for collection typed paths |
class |
ComparableEntityPath<T extends Comparable>
|
class |
ComparablePath<T extends Comparable>
ComparablePath represents Comparable paths |
class |
DatePath<T extends Comparable>
DatePath presents Date paths |
class |
DateTimePath<T extends Comparable>
DateTimePath presents DateTime typed paths |
class |
EntityPathBase<T>
EntityPathBase provides a base class for EntityPath implementations |
class |
EnumPath<T extends Enum<T>>
EnumPath represents enum paths |
class |
ListPath<E,Q extends SimpleExpression<? super E>>
ListPath represents list paths |
class |
MapPath<K,V,E extends SimpleExpression<? super V>>
MapPath represents map paths |
class |
NumberPath<T extends Number & Comparable<?>>
NumberPath represents numeric paths |
class |
PathBuilder<T>
PathBuilder is an extension to EntityPathBase for dynamic path construction |
class |
SetPath<E,Q extends SimpleExpression<? super E>>
SetPath represents set paths |
class |
SimplePath<T>
SimplePath represents simple paths |
class |
StringPath
StringPath represents String typed paths |
class |
TimePath<T extends Comparable>
TimePath represented Time paths |
Methods in com.mysema.query.types.path with type parameters of type SimpleExpression | ||
---|---|---|
protected
|
BeanPath.createCollection(String property,
Class<? super A> type,
Class<? super Q> queryType)
Create a new Collection typed path |
|
protected
|
BeanPath.createList(String property,
Class<? super A> type,
Class<? super E> queryType)
Create a new List typed path |
|
protected
|
BeanPath.createMap(String property,
Class<? super K> key,
Class<? super V> value,
Class<? super E> queryType)
Create a new Map typed path |
|
protected
|
BeanPath.createSet(String property,
Class<? super A> type,
Class<? super E> queryType)
Create a new Set typed path |
|
|
PathBuilder.getCollection(String property,
Class<A> type,
Class<E> queryType)
Get a new Collection typed path |
|
|
PathBuilder.getList(String property,
Class<A> type,
Class<E> queryType)
Get a new List typed path |
|
|
PathBuilder.getMap(String property,
Class<K> key,
Class<V> value,
Class<E> queryType)
Get a new Map typed path |
|
|
PathBuilder.getSet(String property,
Class<A> type,
Class<E> queryType)
Get a new Set typed path |
Uses of SimpleExpression in com.mysema.query.types.query |
---|
Subclasses of SimpleExpression in com.mysema.query.types.query | |
---|---|
class |
BooleanSubQuery
Boolean typed single result subquery |
class |
ComparableSubQuery<T extends Comparable<?>>
Comparable typed single result subquery |
class |
DateSubQuery<T extends Comparable<?>>
Date typed single result subquery |
class |
DateTimeSubQuery<T extends Comparable<?>>
DateTime typed single result subquery |
class |
ListSubQuery<T>
List result subquery |
class |
NumberSubQuery<T extends Number & Comparable<?>>
Number typed single result subquery |
class |
SimpleSubQuery<T>
Object typed single result subquery |
class |
StringSubQuery
String typed single result subquery |
class |
TimeSubQuery<T extends Comparable<?>>
Time typed single result subquery |
Methods in com.mysema.query.types.query that return SimpleExpression | |
---|---|
SimpleExpression<?> |
ListSubQuery.as(Expression<?> alias)
|
Uses of SimpleExpression in com.mysema.query.types.template |
---|
Subclasses of SimpleExpression in com.mysema.query.types.template | |
---|---|
class |
BooleanTemplate
BooleanTemplate is a custom boolean expression |
class |
ComparableTemplate<T extends Comparable<?>>
ComparableTemplate defines custom comparable expressions |
class |
DateTemplate<T extends Comparable<?>>
DateTemplate defines custom date expressions |
class |
DateTimeTemplate<T extends Comparable<?>>
DateTimeTemplate defines custom dateTime expressions |
class |
EnumTemplate<T extends Enum<T>>
EnumTemplate defines custom enum expressions |
class |
NumberTemplate<T extends Number & Comparable<?>>
NumberTemplate defines custom numeric expressions |
class |
SimpleTemplate<T>
SimpleTemplate defines custom simple expressions |
class |
StringTemplate
StringTemplate defines custom String expressions |
class |
TimeTemplate<T extends Comparable<?>>
TimeTemplate defines custom time expressions |
Methods in com.mysema.query.types.template that return SimpleExpression | ||
---|---|---|
static
|
SimpleTemplate.create(Class<? extends T> type,
String template,
Expression<?>... args)
|
|
static
|
SimpleTemplate.create(Class<? extends T> type,
Template template,
Expression<?>... args)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |