Uses of Class
com.mysema.query.types.expr.SimpleExpression

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.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 that return types with arguments of type SimpleExpression
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)
           
 

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 RelationalFunctionCall<T>
          Represents a table valued function call
 class RelationalPathBase<T>
          RelationalPathBase is a base class for RelationPath implements
 

Methods in com.mysema.query.sql that return SimpleExpression
static
<T extends Number>
SimpleExpression<T>
SQLExpressions.nextval(Class<T> type, String sequence)
           
static SimpleExpression<Long> SQLExpressions.nextval(String sequence)
           
<T> SimpleExpression<T>
SQLSubQuery.union(List<? extends SubQueryExpression<T>> sq)
           
<T> SimpleExpression<T>
SQLSubQuery.union(SubQueryExpression<T>... sq)
           
 

Uses of SimpleExpression in com.mysema.query.support
 

Methods in com.mysema.query.support that return SimpleExpression
static
<D> SimpleExpression<D>
Expressions.as(Expression<D> source, Path<D> alias)
           
static
<D> SimpleExpression<D>
Expressions.as(Expression<D> source, String alias)
           
static
<D> SimpleExpression<D>
Expressions.constantAs(D source, Path<D> alias)
           
static
<T> SimpleExpression<T>
Expressions.operation(Class<T> type, Operator<? super T> operator, Expression<?>... args)
           
static
<T> SimpleExpression<T>
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 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
 

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
<D> SimpleExpression<D>
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
 

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 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 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
 

Methods in com.mysema.query.types.path with type parameters of type SimpleExpression
protected
<A,Q extends SimpleExpression<? super A>>
CollectionPath<A,Q>
BeanPath.createCollection(String property, Class<? super A> type, Class<? super Q> queryType)
          Create a new Collection typed path
protected
<A,E extends SimpleExpression<? super A>>
ListPath<A,E>
BeanPath.createList(String property, Class<? super A> type, Class<? super E> queryType)
          Create a new List typed path
protected
<K,V,E extends SimpleExpression<? super V>>
MapPath<K,V,E>
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>>
SetPath<A,E>
BeanPath.createSet(String property, Class<? super A> type, Class<? super E> queryType)
          Create a new Set typed path
<A,E extends SimpleExpression<A>>
CollectionPath<A,E>
PathBuilder.getCollection(String property, Class<A> type, Class<E> queryType)
          Get a new Collection typed path
<A,E extends SimpleExpression<A>>
ListPath<A,E>
PathBuilder.getList(String property, Class<A> type, Class<E> queryType)
          Get a new List typed path
<K,V,E extends SimpleExpression<V>>
MapPath<K,V,E>
PathBuilder.getMap(String property, Class<K> key, Class<V> value, Class<E> queryType)
          Get a new Map typed path
<A,E extends SimpleExpression<A>>
SetPath<A,E>
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 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
 

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
<T> SimpleExpression<T>
SimpleTemplate.create(Class<? extends T> type, String template, Expression<?>... args)
           
static
<T> SimpleExpression<T>
SimpleTemplate.create(Class<? extends T> type, Template template, Expression<?>... args)
           
 



Copyright © 2007-2012 Mysema Ltd. All Rights Reserved.