Package | Description |
---|---|
com.mysema.query.alias |
Alias functionality
|
com.mysema.query.codegen |
Code generations models and serializers
|
com.mysema.query.collections |
Implementations of Querydsl query interfaces for JavaBean collections
|
com.mysema.query.dml |
DML interfaces
|
com.mysema.query.group | |
com.mysema.query.hibernate.search | |
com.mysema.query.jdo |
JDOQL support for Querydsl
|
com.mysema.query.jdo.dml |
DML operations support for Querydsl JDOQL
|
com.mysema.query.jdo.sql | |
com.mysema.query.jpa |
Query implementations for HQL and JPAQL
|
com.mysema.query.jpa.hibernate |
JPQL for Hibernate
|
com.mysema.query.jpa.hibernate.sql | |
com.mysema.query.jpa.impl |
JPQL for JPA
|
com.mysema.query.jpa.sql | |
com.mysema.query.lucene | |
com.mysema.query.mongodb | |
com.mysema.query.mongodb.morphia | |
com.mysema.query.sql |
SQL/JDBC support for Querydsl
|
com.mysema.query.sql.dml |
DML operations support
|
com.mysema.query.support |
Various support classes
|
com.mysema.query.types |
Contains Querydsl grammar types
|
com.mysema.query.types.expr |
Operations represent typed operations with operator and arguments
|
com.mysema.query.types.path |
Paths represent typed property paths, variables and list-map-array access
|
Modifier and Type | Method and Description |
---|---|
<T> Path<T[]> |
PathFactory.createArrayPath(Class<T[]> type,
PathMetadata<?> metadata) |
<T> Path<T[]> |
DefaultPathFactory.createArrayPath(Class<T[]> arrayType,
PathMetadata<?> metadata) |
Path<Boolean> |
PathFactory.createBooleanPath(PathMetadata<?> metadata) |
Path<Boolean> |
DefaultPathFactory.createBooleanPath(PathMetadata<?> metadata) |
<E> Path<Collection<E>> |
PathFactory.createCollectionPath(Class<E> elementType,
PathMetadata<?> metadata) |
<E> Path<Collection<E>> |
DefaultPathFactory.createCollectionPath(Class<E> elementType,
PathMetadata<?> metadata) |
<T extends Comparable<?>> |
PathFactory.createComparablePath(Class<T> type,
PathMetadata<?> metadata) |
<T extends Comparable<?>> |
DefaultPathFactory.createComparablePath(Class<T> type,
PathMetadata<?> metadata) |
<T extends Comparable<?>> |
PathFactory.createDatePath(Class<T> type,
PathMetadata<?> metadata) |
<T extends Comparable<?>> |
DefaultPathFactory.createDatePath(Class<T> type,
PathMetadata<?> metadata) |
<T extends Comparable<?>> |
PathFactory.createDateTimePath(Class<T> type,
PathMetadata<?> metadata) |
<T extends Comparable<?>> |
DefaultPathFactory.createDateTimePath(Class<T> type,
PathMetadata<?> metadata) |
<T> Path<T> |
PathFactory.createEntityPath(Class<T> type,
PathMetadata<?> metadata) |
<T> Path<T> |
DefaultPathFactory.createEntityPath(Class<T> type,
PathMetadata<?> metadata) |
<T extends Enum<T>> |
PathFactory.createEnumPath(Class<T> type,
PathMetadata<?> metadata) |
<T extends Enum<T>> |
DefaultPathFactory.createEnumPath(Class<T> type,
PathMetadata<?> metadata) |
<E> Path<List<E>> |
PathFactory.createListPath(Class<E> elementType,
PathMetadata<?> metadata) |
<E> Path<List<E>> |
DefaultPathFactory.createListPath(Class<E> elementType,
PathMetadata<?> metadata) |
<K,V> Path<Map<K,V>> |
PathFactory.createMapPath(Class<K> keyType,
Class<V> valueType,
PathMetadata<?> metadata) |
<K,V> Path<Map<K,V>> |
DefaultPathFactory.createMapPath(Class<K> keyType,
Class<V> valueType,
PathMetadata<?> metadata) |
<T extends Number & Comparable<T>> |
PathFactory.createNumberPath(Class<T> type,
PathMetadata<?> metadata) |
<T extends Number & Comparable<T>> |
DefaultPathFactory.createNumberPath(Class<T> type,
PathMetadata<?> metadata) |
<E> Path<Set<E>> |
PathFactory.createSetPath(Class<E> elementType,
PathMetadata<?> metadata) |
<E> Path<Set<E>> |
DefaultPathFactory.createSetPath(Class<E> elementType,
PathMetadata<?> metadata) |
<T> Path<T> |
PathFactory.createSimplePath(Class<T> type,
PathMetadata<?> metadata) |
<T> Path<T> |
DefaultPathFactory.createSimplePath(Class<T> type,
PathMetadata<?> metadata) |
Path<String> |
PathFactory.createStringPath(PathMetadata<?> metadata) |
Path<String> |
DefaultPathFactory.createStringPath(PathMetadata<?> metadata) |
<T extends Comparable<?>> |
PathFactory.createTimePath(Class<T> type,
PathMetadata<?> metadata) |
<T extends Comparable<?>> |
DefaultPathFactory.createTimePath(Class<T> type,
PathMetadata<?> metadata) |
Modifier and Type | Method and Description |
---|---|
protected PathMetadata<Integer> |
PropertyAccessInvocationHandler.createListAccessPath(Path<?> path,
Integer index) |
protected PathMetadata<?> |
PropertyAccessInvocationHandler.createMapAccessPath(Path<?> path,
Object key) |
protected PathMetadata<String> |
PropertyAccessInvocationHandler.createPropertyPath(Path<?> path,
String propertyName) |
Modifier and Type | Method and Description |
---|---|
void |
TypeMappings.register(com.mysema.codegen.model.TypeCategory category,
Class<? extends Expression> expr,
Class<? extends Path> path,
Class<? extends TemplateExpression> template) |
Modifier and Type | Method and Description |
---|---|
<A> Q |
AbstractCollQuery.bind(Path<A> entity,
Iterable<? extends A> col)
Bind the given collection to an already existing query source
|
static <A> CollDeleteClause<A> |
CollQueryFactory.delete(Path<A> path,
Collection<A> col)
Create a new delete clause
|
static <A> CollQuery |
CollQueryFactory.from(Path<A> path,
A... arr)
Create a new query
|
<A> Q |
AbstractCollQuery.from(Path<A> entity,
Iterable<? extends A> col)
Add a query source
|
static <A> CollQuery |
CollQueryFactory.from(Path<A> path,
Iterable<A> col)
Create a new query
|
static <T,P> org.hamcrest.Matcher<T> |
PathMatcher.hasValue(Path<P> path) |
static <T,P> org.hamcrest.Matcher<T> |
PathMatcher.hasValue(Path<P> path,
org.hamcrest.Matcher<? super P> matcher) |
<P> Q |
AbstractCollQuery.innerJoin(MapExpression<?,P> target,
Path<P> alias)
Define an inner join from the Map typed path to the alias
|
<P> Q |
AbstractCollQuery.innerJoin(Path<? extends Collection<P>> target,
Path<P> alias)
Define an inner join from the Collection typed path to the alias
|
<P> Q |
AbstractCollQuery.innerJoin(Path<? extends Collection<P>> target,
Path<P> alias)
Define an inner join from the Collection typed path to the alias
|
<P> Q |
AbstractCollQuery.leftJoin(MapExpression<?,P> target,
Path<P> alias)
Define a left join from the Map typed path to the alias
|
<P> Q |
AbstractCollQuery.leftJoin(Path<? extends Collection<P>> target,
Path<P> alias)
Define a left join from the Collection typed path to the alias
|
<P> Q |
AbstractCollQuery.leftJoin(Path<? extends Collection<P>> target,
Path<P> alias)
Define a left join from the Collection typed path to the alias
|
static <T,V extends Comparable<V>> |
PathComparator.pathComparator(Path<V> comparingPath) |
<U> CollUpdateClause<T> |
CollUpdateClause.set(Path<U> path,
Expression<? extends U> expression) |
<U> CollUpdateClause<T> |
CollUpdateClause.set(Path<U> path,
U value) |
<U> CollUpdateClause<T> |
CollUpdateClause.setNull(Path<U> path) |
static <A> CollUpdateClause<A> |
CollQueryFactory.update(Path<A> path,
Iterable<A> col)
Create a new update clause
|
Void |
CollQuerySerializer.visit(Path<?> path,
Void context) |
Modifier and Type | Method and Description |
---|---|
CollUpdateClause<T> |
CollUpdateClause.set(List<? extends Path<?>> p,
List<?> v) |
Constructor and Description |
---|
CollDeleteClause(Path<T> expr,
Collection<? extends T> col) |
CollDeleteClause(QueryEngine qe,
Path<T> expr,
Collection<? extends T> col) |
CollUpdateClause(Path<T> expr,
Iterable<? extends T> col) |
CollUpdateClause(QueryEngine qe,
Path<T> expr,
Iterable<? extends T> col) |
PathComparator(Path<V> comparingPath) |
PathComparator(Path<V> comparingPath,
com.google.common.base.Function<T,V> accessor) |
PathMatcher(Path<V> path,
org.hamcrest.Matcher<? super V> matcher) |
PathMatcher(Path<V> path,
org.hamcrest.Matcher<? super V> matcher,
com.google.common.base.Function<T,V> accessor) |
Modifier and Type | Method and Description |
---|---|
C |
InsertClause.columns(Path<?>... columns)
Define the columns to be populated
|
<T> C |
StoreClause.set(Path<T> path,
Expression<? extends T> expression)
Add an expression binding
|
<T> C |
StoreClause.set(Path<T> path,
T value)
Add a value binding
|
<T> C |
StoreClause.setNull(Path<T> path)
Bind the given path to null
|
Modifier and Type | Method and Description |
---|---|
C |
UpdateClause.set(List<? extends Path<?>> paths,
List<?> values)
Set the paths to be updated
|
Modifier and Type | Method and Description |
---|---|
DslExpression<R> |
AbstractGroupExpression.as(Path<R> alias)
Create an alias for the expression
|
Modifier and Type | Method and Description |
---|---|
String |
SearchSerializer.toField(Path<?> path) |
Modifier and Type | Method and Description |
---|---|
Void |
JDOQLSerializer.visit(Path<?> path,
Void context) |
Modifier and Type | Method and Description |
---|---|
<T> JDOUpdateClause |
JDOUpdateClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> JDOUpdateClause |
JDOUpdateClause.set(Path<T> path,
T value) |
<T> JDOUpdateClause |
JDOUpdateClause.setNull(Path<T> path) |
Modifier and Type | Method and Description |
---|---|
JDOUpdateClause |
JDOUpdateClause.set(List<? extends Path<?>> paths,
List<?> values) |
Modifier and Type | Method and Description |
---|---|
T |
AbstractSQLQuery.from(SubQueryExpression<?> subQuery,
Path<?> alias) |
<E> T |
AbstractSQLQuery.fullJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
T |
AbstractSQLQuery.fullJoin(SubQueryExpression<?> o,
Path<?> alias) |
<E> T |
AbstractSQLQuery.innerJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
T |
AbstractSQLQuery.innerJoin(SubQueryExpression<?> o,
Path<?> alias) |
<E> T |
AbstractSQLQuery.join(RelationalFunctionCall<E> target,
Path<E> alias) |
T |
AbstractSQLQuery.join(SubQueryExpression<?> o,
Path<?> alias) |
<E> T |
AbstractSQLQuery.leftJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
T |
AbstractSQLQuery.leftJoin(SubQueryExpression<?> o,
Path<?> alias) |
<E> T |
AbstractSQLQuery.rightJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
T |
AbstractSQLQuery.rightJoin(SubQueryExpression<?> o,
Path<?> alias) |
<RT> T |
AbstractSQLQuery.union(Path<?> alias,
ListSubQuery<RT>... sq) |
<RT> T |
AbstractSQLQuery.union(Path<?> alias,
SubQueryExpression<RT>... sq) |
<RT> T |
AbstractSQLQuery.unionAll(Path<?> alias,
ListSubQuery<RT>... sq) |
<RT> T |
AbstractSQLQuery.unionAll(Path<?> alias,
SubQueryExpression<RT>... sq) |
Modifier and Type | Method and Description |
---|---|
List<Path<?>> |
NativeSQLSerializer.getEntityPaths() |
Modifier and Type | Method and Description |
---|---|
T |
AbstractSQLQuery.from(SubQueryExpression<?> subQuery,
Path<?> alias) |
<P> Q |
AbstractJPASubQuery.fullJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.fullJoin(CollectionExpression<?,P> target,
Path<P> alias)
Create a full join with the given target and alias.
|
<P> Q |
JPAQueryBase.fullJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> Q |
AbstractJPASubQuery.fullJoin(EntityPath<P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.fullJoin(EntityPath<P> target,
Path<P> alias)
Create a full join with the given target and alias.
|
<P> Q |
JPAQueryBase.fullJoin(EntityPath<P> target,
Path<P> alias) |
<P> Q |
AbstractJPASubQuery.fullJoin(MapExpression<?,P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.fullJoin(MapExpression<?,P> target,
Path<P> alias)
Create a full join with the given target and alias.
|
<P> Q |
JPAQueryBase.fullJoin(MapExpression<?,P> target,
Path<P> alias) |
<E> T |
AbstractSQLQuery.fullJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
T |
AbstractSQLQuery.fullJoin(SubQueryExpression<?> o,
Path<?> alias) |
<P> Q |
AbstractJPASubQuery.innerJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.innerJoin(CollectionExpression<?,P> target,
Path<P> alias)
Create a inner join with the given target and alias.
|
<P> Q |
JPAQueryBase.innerJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> Q |
AbstractJPASubQuery.innerJoin(EntityPath<P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.innerJoin(EntityPath<P> target,
Path<P> alias)
Create a inner join with the given target and alias.
|
<P> Q |
JPAQueryBase.innerJoin(EntityPath<P> target,
Path<P> alias) |
<P> Q |
AbstractJPASubQuery.innerJoin(MapExpression<?,P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.innerJoin(MapExpression<?,P> target,
Path<P> alias)
Create a inner join with the given target and alias.
|
<P> Q |
JPAQueryBase.innerJoin(MapExpression<?,P> target,
Path<P> alias) |
<E> T |
AbstractSQLQuery.innerJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
T |
AbstractSQLQuery.innerJoin(SubQueryExpression<?> o,
Path<?> alias) |
<P> Q |
AbstractJPASubQuery.join(CollectionExpression<?,P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.join(CollectionExpression<?,P> target,
Path<P> alias) |
<P> Q |
JPAQueryBase.join(CollectionExpression<?,P> target,
Path<P> alias) |
<P> Q |
AbstractJPASubQuery.join(EntityPath<P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.join(EntityPath<P> target,
Path<P> alias)
Create a join with the given target and alias.
|
<P> Q |
JPAQueryBase.join(EntityPath<P> target,
Path<P> alias) |
<P> Q |
AbstractJPASubQuery.join(MapExpression<?,P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.join(MapExpression<?,P> target,
Path<P> alias)
Create a join with the given target and alias.
|
<P> Q |
JPAQueryBase.join(MapExpression<?,P> target,
Path<P> alias) |
<E> T |
AbstractSQLQuery.join(RelationalFunctionCall<E> target,
Path<E> alias) |
T |
AbstractSQLQuery.join(SubQueryExpression<?> o,
Path<?> alias) |
<P> Q |
AbstractJPASubQuery.leftJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.leftJoin(CollectionExpression<?,P> target,
Path<P> alias)
Create a left join with the given target and alias.
|
<P> Q |
JPAQueryBase.leftJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> Q |
AbstractJPASubQuery.leftJoin(EntityPath<P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.leftJoin(EntityPath<P> target,
Path<P> alias)
Create a left join with the given target and alias.
|
<P> Q |
JPAQueryBase.leftJoin(EntityPath<P> target,
Path<P> alias) |
<P> Q |
AbstractJPASubQuery.leftJoin(MapExpression<?,P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.leftJoin(MapExpression<?,P> target,
Path<P> alias)
Create a left join with the given target and alias.
|
<P> Q |
JPAQueryBase.leftJoin(MapExpression<?,P> target,
Path<P> alias) |
<E> T |
AbstractSQLQuery.leftJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
T |
AbstractSQLQuery.leftJoin(SubQueryExpression<?> o,
Path<?> alias) |
<P> Q |
AbstractJPASubQuery.rightJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.rightJoin(CollectionExpression<?,P> target,
Path<P> alias)
Create a right join with the given target and alias.
|
<P> Q |
JPAQueryBase.rightJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> Q |
AbstractJPASubQuery.rightJoin(EntityPath<P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.rightJoin(EntityPath<P> target,
Path<P> alias)
Create a right join with the given target and alias.
|
<P> Q |
JPAQueryBase.rightJoin(EntityPath<P> target,
Path<P> alias) |
<P> Q |
AbstractJPASubQuery.rightJoin(MapExpression<?,P> target,
Path<P> alias) |
<P> Q |
JPACommonQuery.rightJoin(MapExpression<?,P> target,
Path<P> alias)
Create a right join with the given target and alias.
|
<P> Q |
JPAQueryBase.rightJoin(MapExpression<?,P> target,
Path<P> alias) |
<E> T |
AbstractSQLQuery.rightJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
T |
AbstractSQLQuery.rightJoin(SubQueryExpression<?> o,
Path<?> alias) |
Void |
NativeSQLSerializer.visit(Path<?> path,
Void context) |
Void |
JPQLSerializer.visit(Path<?> expr,
Void context) |
Modifier and Type | Field and Description |
---|---|
protected Map<Path<?>,org.hibernate.LockMode> |
AbstractHibernateQuery.lockModes |
Modifier and Type | Method and Description |
---|---|
<T> HibernateUpdateClause |
HibernateUpdateClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> HibernateUpdateClause |
HibernateUpdateClause.set(Path<T> path,
T value) |
Q |
AbstractHibernateQuery.setLockMode(Path<?> path,
org.hibernate.LockMode lockMode)
Set the lock mode for the given path.
|
<T> HibernateUpdateClause |
HibernateUpdateClause.setNull(Path<T> path) |
Modifier and Type | Method and Description |
---|---|
HibernateUpdateClause |
HibernateUpdateClause.set(List<? extends Path<?>> paths,
List<?> values) |
Modifier and Type | Method and Description |
---|---|
<RT> Q |
AbstractHibernateSQLQuery.union(Path<?> alias,
ListSubQuery<RT>... sq) |
<RT> Q |
AbstractHibernateSQLQuery.union(Path<?> alias,
SubQueryExpression<RT>... sq) |
<RT> Q |
AbstractHibernateSQLQuery.unionAll(Path<?> alias,
ListSubQuery<RT>... sq) |
<RT> Q |
AbstractHibernateSQLQuery.unionAll(Path<?> alias,
SubQueryExpression<RT>... sq) |
Modifier and Type | Method and Description |
---|---|
<T> JPAUpdateClause |
JPAUpdateClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> JPAUpdateClause |
JPAUpdateClause.set(Path<T> path,
T value) |
<T> JPAUpdateClause |
JPAUpdateClause.setNull(Path<T> path) |
Modifier and Type | Method and Description |
---|---|
JPAUpdateClause |
JPAUpdateClause.set(List<? extends Path<?>> paths,
List<?> values) |
Modifier and Type | Method and Description |
---|---|
<RT> Q |
AbstractJPASQLQuery.union(Path<?> alias,
ListSubQuery<RT>... sq) |
<RT> Q |
AbstractJPASQLQuery.union(Path<?> alias,
SubQueryExpression<RT>... sq) |
<RT> Q |
AbstractJPASQLQuery.unionAll(Path<?> alias,
ListSubQuery<RT>... sq) |
<RT> Q |
AbstractJPASQLQuery.unionAll(Path<?> alias,
SubQueryExpression<RT>... sq) |
Modifier and Type | Method and Description |
---|---|
protected String[] |
LuceneSerializer.convert(Path<?> leftHandSide,
Expression<?> rightHandSide,
QueryMetadata metadata)
template method
|
protected String[] |
LuceneSerializer.convert(Path<?> leftHandSide,
Object rightHandSide)
template method
|
Q |
AbstractLuceneQuery.distinct(Path<?> property)
Add a DuplicateFilter for the field of the given property path
|
static BooleanExpression |
LuceneExpressions.fuzzyLike(Path<String> path,
String value)
Create a fuzzy query
|
static BooleanExpression |
LuceneExpressions.fuzzyLike(Path<String> path,
String value,
float minimumSimilarity)
Create a fuzzy query
|
static BooleanExpression |
LuceneExpressions.fuzzyLike(Path<String> path,
String value,
float minimumSimilarity,
int prefixLength)
Create a fuzzy query
|
Q |
AbstractLuceneQuery.load(Path<?>... paths)
Load only the fields of the given paths
|
protected org.apache.lucene.search.Query |
LuceneSerializer.range(Path<?> leftHandSide,
String field,
Expression<?> min,
Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected org.apache.lucene.search.Query |
LuceneSerializer.stringRange(Path<?> leftHandSide,
String field,
Expression<?> min,
Expression<?> max,
boolean minInc,
boolean maxInc,
QueryMetadata metadata) |
protected String |
LuceneSerializer.toField(Path<?> path)
template method, override to customize
|
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 |
---|---|
<T> AnyEmbeddedBuilder<K> |
MongodbQuery.anyEmbedded(Path<? extends Collection<T>> collection,
Path<T> target)
Define a constraint for an embedded object
|
<T> AnyEmbeddedBuilder<K> |
MongodbQuery.anyEmbedded(Path<? extends Collection<T>> collection,
Path<T> target)
Define a constraint for an embedded object
|
protected String |
MongodbSerializer.getKeyForPath(Path<?> expr,
PathMetadata<?> metadata) |
com.mysema.commons.lang.CloseableIterator<K> |
MongodbQuery.iterate(Path<?>... paths) |
<T> JoinBuilder<K,T> |
MongodbQuery.join(CollectionPathBase<?,T,?> ref,
Path<T> target)
Define a join
|
<T> JoinBuilder<K,T> |
MongodbQuery.join(Path<T> ref,
Path<T> target)
Define a join
|
<T> JoinBuilder<K,T> |
MongodbQuery.join(Path<T> ref,
Path<T> target)
Define a join
|
List<K> |
MongodbQuery.list(Path<?>... paths) |
SearchResults<K> |
MongodbQuery.listResults(Path<?>... paths) |
K |
MongodbQuery.singleResult(Path<?>... paths) |
K |
MongodbQuery.uniqueResult(Path<?>... paths) |
String |
MongodbSerializer.visit(Path<?> expr,
Void context) |
Constructor and Description |
---|
AnyEmbeddedBuilder(QueryMixin<MongodbQuery<K>> queryMixin,
Path<? extends Collection<?>> collection) |
JoinBuilder(QueryMixin<MongodbQuery<K>> queryMixin,
Path<?> ref,
Path<T> target) |
JoinBuilder(QueryMixin<MongodbQuery<K>> queryMixin,
Path<?> ref,
Path<T> target) |
Point(Path<?> parent,
String property) |
Modifier and Type | Method and Description |
---|---|
protected String |
MorphiaSerializer.getKeyForPath(Path<?> expr,
PathMetadata<?> metadata) |
Modifier and Type | Interface and Description |
---|---|
interface |
RelationalPath<T>
RelationalPath extends
EntityPath to provide access to relational metadata |
Modifier and Type | Class and Description |
---|---|
class |
RelationalPathBase<T>
RelationalPathBase is a base class for
RelationalPath implementations |
Modifier and Type | Method and Description |
---|---|
protected <P extends Path<?>> |
RelationalPathBase.add(P path) |
Modifier and Type | Method and Description |
---|---|
Path<?>[] |
RelationalPathBase.all() |
Modifier and Type | Method and Description |
---|---|
List<Path<?>> |
RelationalPath.getColumns()
Get all columns
|
List<Path<?>> |
RelationalPathBase.getColumns() |
List<Path<?>> |
SQLSerializer.getConstantPaths() |
List<? extends Path<?>> |
ForeignKey.getLocalColumns() |
List<? extends Path<?>> |
PrimaryKey.getLocalColumns() |
Modifier and Type | Method and Description |
---|---|
protected <F> ForeignKey<F> |
RelationalPathBase.createForeignKey(Path<?> local,
String foreign) |
protected <F> ForeignKey<F> |
RelationalPathBase.createInvForeignKey(Path<?> local,
String foreign) |
protected PrimaryKey<T> |
RelationalPathBase.createPrimaryKey(Path<?>... columns) |
Q |
AbstractSQLSubQuery.from(SubQueryExpression<?> subQuery,
Path<?> alias) |
Q |
AbstractSQLQuery.from(SubQueryExpression<?> subQuery,
Path<?> alias) |
Q |
SQLCommonQuery.from(SubQueryExpression<?> subQuery,
Path<?> alias)
Adds a sub query source
|
<E> Q |
AbstractSQLSubQuery.fullJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
<E> Q |
AbstractSQLQuery.fullJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
<E> Q |
SQLCommonQuery.fullJoin(RelationalFunctionCall<E> o,
Path<E> alias)
Adds a full join to the given target
|
Q |
AbstractSQLSubQuery.fullJoin(SubQueryExpression<?> target,
Path<?> alias) |
Q |
AbstractSQLQuery.fullJoin(SubQueryExpression<?> target,
Path<?> alias) |
Q |
SQLCommonQuery.fullJoin(SubQueryExpression<?> o,
Path<?> alias)
Adds a full join to the given target
|
<T> T |
Configuration.get(ResultSet rs,
Path<?> path,
int i,
Class<T> clazz) |
<E> Q |
AbstractSQLSubQuery.innerJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
<E> Q |
AbstractSQLQuery.innerJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
<E> Q |
SQLCommonQuery.innerJoin(RelationalFunctionCall<E> o,
Path<E> alias)
Adds a full join to the given target
|
Q |
AbstractSQLSubQuery.innerJoin(SubQueryExpression<?> target,
Path<?> alias) |
Q |
AbstractSQLQuery.innerJoin(SubQueryExpression<?> target,
Path<?> alias) |
Q |
SQLCommonQuery.innerJoin(SubQueryExpression<?> o,
Path<?> alias)
Adds an inner join to the given target
|
<E> Q |
AbstractSQLSubQuery.join(RelationalFunctionCall<E> target,
Path<E> alias) |
<E> Q |
AbstractSQLQuery.join(RelationalFunctionCall<E> target,
Path<E> alias) |
<E> Q |
SQLCommonQuery.join(RelationalFunctionCall<E> o,
Path<E> alias)
Adds a full join to the given target
|
Q |
AbstractSQLSubQuery.join(SubQueryExpression<?> target,
Path<?> alias) |
Q |
AbstractSQLQuery.join(SubQueryExpression<?> target,
Path<?> alias) |
Q |
SQLCommonQuery.join(SubQueryExpression<?> o,
Path<?> alias)
Adds a join to the given target
|
<E> Q |
AbstractSQLSubQuery.leftJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
<E> Q |
AbstractSQLQuery.leftJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
<E> Q |
SQLCommonQuery.leftJoin(RelationalFunctionCall<E> o,
Path<E> alias)
Adds a full join to the given target
|
Q |
AbstractSQLSubQuery.leftJoin(SubQueryExpression<?> target,
Path<?> alias) |
Q |
AbstractSQLQuery.leftJoin(SubQueryExpression<?> target,
Path<?> alias) |
Q |
SQLCommonQuery.leftJoin(SubQueryExpression<?> o,
Path<?> alias)
Adds a left join to the given target
|
<E> Q |
AbstractSQLSubQuery.rightJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
<E> Q |
AbstractSQLQuery.rightJoin(RelationalFunctionCall<E> target,
Path<E> alias) |
<E> Q |
SQLCommonQuery.rightJoin(RelationalFunctionCall<E> o,
Path<E> alias)
Adds a full join to the given target
|
Q |
AbstractSQLSubQuery.rightJoin(SubQueryExpression<?> target,
Path<?> alias) |
Q |
AbstractSQLQuery.rightJoin(SubQueryExpression<?> target,
Path<?> alias) |
Q |
SQLCommonQuery.rightJoin(SubQueryExpression<?> o,
Path<?> alias)
Adds a right join to the given target
|
<T> void |
Configuration.set(PreparedStatement stmt,
Path<?> path,
int i,
T value) |
<RT> Q |
AbstractSQLQuery.union(Path<?> alias,
ListSubQuery<RT>... sq)
Creates an union expression for the given subqueries
|
<RT> Q |
AbstractSQLQuery.union(Path<?> alias,
SubQueryExpression<RT>... sq)
Creates an union expression for the given subqueries
|
static Expression<?> |
UnionUtils.union(SubQueryExpression<?>[] union,
Path<?> alias,
boolean unionAll) |
<RT> Q |
AbstractSQLQuery.unionAll(Path<?> alias,
ListSubQuery<RT>... sq)
Creates an union expression for the given subqueries
|
<RT> Q |
AbstractSQLQuery.unionAll(Path<?> alias,
SubQueryExpression<RT>... sq)
Creates an union expression for the given subqueries
|
Void |
SQLSerializer.visit(Path<?> path,
Void context) |
Modifier and Type | Method and Description |
---|---|
protected <F> ForeignKey<F> |
RelationalPathBase.createForeignKey(List<? extends Path<?>> local,
List<String> foreign) |
protected <F> ForeignKey<F> |
RelationalPathBase.createInvForeignKey(List<? extends Path<?>> local,
List<String> foreign) |
void |
SQLSerializer.serializeForInsert(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLSerializer.serializeForMerge(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLSerializer.serializeForMerge(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLSerializer.serializeForUpdate(QueryMetadata metadata,
RelationalPath<?> entity,
List<com.mysema.commons.lang.Pair<Path<?>,Expression<?>>> updates) |
protected void |
AbstractSQLQuery.setParameters(PreparedStatement stmt,
List<?> objects,
List<Path<?>> constantPaths,
Map<ParamExpression<?>,?> params) |
Constructor and Description |
---|
ForeignKey(RelationalPath<?> entity,
Path<?> localColumn,
String foreignColumn) |
PrimaryKey(RelationalPath<?> entity,
Path<?>... localColumns) |
Constructor and Description |
---|
ForeignKey(RelationalPath<?> entity,
com.google.common.collect.ImmutableList<? extends Path<?>> localColumns,
com.google.common.collect.ImmutableList<String> foreignColumns) |
PrimaryKey(RelationalPath<?> entity,
com.google.common.collect.ImmutableList<? extends Path<?>> localColumns) |
Modifier and Type | Method and Description |
---|---|
Map<Path<?>,Object> |
BeanMapper.createMap(RelationalPath<?> entity,
Object bean) |
Map<Path<?>,Object> |
DefaultMapper.createMap(RelationalPath<?> entity,
Object bean) |
Map<Path<?>,Object> |
AnnotationMapper.createMap(RelationalPath<?> path,
Object object) |
Map<Path<?>,Object> |
Mapper.createMap(RelationalPath<?> path,
T object) |
List<Path<?>> |
SQLMergeBatch.getColumns() |
List<Path<?>> |
SQLInsertBatch.getColumns() |
List<Path<?>> |
SQLMergeBatch.getKeys() |
Modifier and Type | Method and Description |
---|---|
SQLMergeClause |
SQLMergeClause.columns(Path<?>... columns) |
SQLInsertClause |
SQLInsertClause.columns(Path<?>... columns) |
<T> T |
SQLInsertClause.executeWithKey(Path<T> path)
Execute the clause and return the generated key with the type of the given path.
|
<T> List<T> |
SQLInsertClause.executeWithKeys(Path<T> path)
Execute the clause and return the generated keys with the type of the given path.
|
protected boolean |
AbstractMapper.isPrimaryKeyColumn(RelationalPath<?> parent,
Path<?> property) |
SQLMergeClause |
SQLMergeClause.keys(Path<?>... paths)
Set the keys to be used in the MERGE clause
|
<T> SQLMergeClause |
SQLMergeClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> SQLInsertClause |
SQLInsertClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> SQLUpdateClause |
SQLUpdateClause.set(Path<T> path,
Expression<? extends T> expression) |
<T> SQLMergeClause |
SQLMergeClause.set(Path<T> path,
T value) |
<T> SQLInsertClause |
SQLInsertClause.set(Path<T> path,
T value) |
<T> SQLUpdateClause |
SQLUpdateClause.set(Path<T> path,
T value) |
<T> SQLMergeClause |
SQLMergeClause.setNull(Path<T> path) |
<T> SQLInsertClause |
SQLInsertClause.setNull(Path<T> path) |
<T> SQLUpdateClause |
SQLUpdateClause.setNull(Path<T> path) |
Modifier and Type | Method and Description |
---|---|
SQLUpdateClause |
SQLUpdateClause.set(List<? extends Path<?>> paths,
List<?> values) |
protected void |
AbstractSQLClause.setParameters(PreparedStatement stmt,
List<?> objects,
List<Path<?>> constantPaths,
Map<ParamExpression<?>,?> params)
Set the parameters to the given PreparedStatement
|
Constructor and Description |
---|
SQLInsertBatch(List<Path<?>> c,
List<Expression<?>> v,
SubQueryExpression<?> sq) |
SQLMergeBatch(List<Path<?>> k,
List<Path<?>> c,
List<Expression<?>> v,
SubQueryExpression<?> sq) |
SQLMergeBatch(List<Path<?>> k,
List<Path<?>> c,
List<Expression<?>> v,
SubQueryExpression<?> sq) |
Modifier and Type | Field and Description |
---|---|
List<Path<?>> |
Context.paths |
Modifier and Type | Method and Description |
---|---|
void |
Context.add(Path<?> anyPath,
EntityPath<?> replacement) |
static <D> SimpleExpression<D> |
Expressions.as(Expression<D> source,
Path<D> alias) |
static BooleanPath |
Expressions.booleanPath(Path<?> parent,
String property)
Create a new Path expression
|
static <T extends Comparable<?>> |
Expressions.comparablePath(Class<T> type,
Path<?> parent,
String property)
Create a new Path expression
|
static <D> SimpleExpression<D> |
Expressions.constantAs(D source,
Path<D> alias)
Get the alias expression source as alias
|
protected <D> Expression<D> |
QueryMixin.createAlias(Expression expr,
Path alias) |
static <T extends Comparable<?>> |
Expressions.datePath(Class<T> type,
Path<?> parent,
String property)
Create a new Path expression
|
static <T extends Comparable<?>> |
Expressions.dateTimePath(Class<T> type,
Path<?> parent,
String property)
Create a new Path expression
|
static <T> DslPath<T> |
Expressions.dslPath(Class<T> type,
Path<?> parent,
String property)
Create a new Path expression
|
<P> T |
QueryMixin.fullJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> T |
QueryMixin.fullJoin(Expression<P> target,
Path<P> alias) |
<P> T |
QueryMixin.fullJoin(MapExpression<?,P> target,
Path<P> alias) |
<P> T |
QueryMixin.fullJoin(SubQueryExpression<P> target,
Path alias) |
<P> T |
QueryMixin.innerJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> T |
QueryMixin.innerJoin(Expression<P> target,
Path<P> alias) |
<P> T |
QueryMixin.innerJoin(MapExpression<?,P> target,
Path<P> alias) |
<P> T |
QueryMixin.innerJoin(SubQueryExpression<P> target,
Path alias) |
<P> T |
QueryMixin.join(CollectionExpression<?,P> target,
Path<P> alias) |
<P> T |
QueryMixin.join(Expression<P> target,
Path<P> alias) |
<P> T |
QueryMixin.join(MapExpression<?,P> target,
Path<P> alias) |
<P> T |
QueryMixin.join(SubQueryExpression<P> target,
Path alias) |
<P> T |
QueryMixin.leftJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> T |
QueryMixin.leftJoin(Expression<P> target,
Path<P> alias) |
<P> T |
QueryMixin.leftJoin(MapExpression<?,P> target,
Path<P> alias) |
<P> T |
QueryMixin.leftJoin(SubQueryExpression<P> target,
Path alias) |
static <T extends Number & Comparable<?>> |
Expressions.numberPath(Class<T> type,
Path<?> parent,
String property)
Create a new Path expression
|
static <T> SimplePath<T> |
Expressions.path(Class<T> type,
Path<?> parent,
String property)
Create a new Path expression
|
<P> T |
QueryMixin.rightJoin(CollectionExpression<?,P> target,
Path<P> alias) |
<P> T |
QueryMixin.rightJoin(Expression<P> target,
Path<P> alias) |
<P> T |
QueryMixin.rightJoin(MapExpression<?,P> target,
Path<P> alias) |
<P> T |
QueryMixin.rightJoin(SubQueryExpression<P> target,
Path alias) |
static StringPath |
Expressions.stringPath(Path<?> parent,
String property)
Create a new Path expression
|
static <T extends Comparable<?>> |
Expressions.timePath(Class<T> type,
Path<?> parent,
String property)
Create a new Path expression
|
Expression<?> |
CollectionAnyVisitor.visit(Path<?> expr,
Context context) |
Expression<?> |
ListAccessVisitor.visit(Path<?> expr,
Context context) |
Void |
SerializerBase.visit(Path<?> path,
Void context) |
Modifier and Type | Interface and Description |
---|---|
interface |
EntityPath<T>
EntityPath is the common interface for entity path expressions
|
Modifier and Type | Class and Description |
---|---|
class |
PathImpl<T>
PathImpl defines a default implementation of the
Path interface |
Modifier and Type | Method and Description |
---|---|
Path<?> |
PathMetadata.getParent() |
Path<?> |
Path.getRoot()
Get the root for this path
|
Path<?> |
PathImpl.getRoot() |
Path<?> |
PathMetadata.getRoot() |
Path<?> |
PathExtractor.visit(Constant<?> expr,
Void context) |
Path<?> |
PathExtractor.visit(FactoryExpression<?> expr,
Void context) |
Path<?> |
PathExtractor.visit(Operation<?> expr,
Void context) |
Path<?> |
PathExtractor.visit(ParamExpression<?> expr,
Void context) |
Path<?> |
PathExtractor.visit(Path<?> expr,
Void context) |
Path<?> |
PathExtractor.visit(SubQueryExpression<?> expr,
Void context) |
Path<?> |
PathExtractor.visit(TemplateExpression<?> expr,
Void context) |
Modifier and Type | Method and Description |
---|---|
static <D> Expression<D> |
ExpressionUtils.as(Expression<D> source,
Path<D> alias)
Create an alias expression (source as alias) with the given source and alias
|
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
|
static <T> QBean<T> |
Projections.bean(Path<T> type,
Expression<?>... exprs)
Create a Bean populating projection for the given type and expressions
|
static <T> QBean<T> |
Projections.fields(Path<T> type,
Expression<?>... exprs)
Create a field access based Bean populating projection for the given type and expressions
|
static PathMetadata<Integer> |
PathMetadataFactory.forArrayAccess(Path<?> parent,
Expression<Integer> index)
Create a new PathMetadata for indexed array access
|
static PathMetadata<Integer> |
PathMetadataFactory.forArrayAccess(Path<?> parent,
int index)
Create a new PathMetadata for indexed array access
|
static PathMetadata<?> |
PathMetadataFactory.forCollectionAny(Path<?> parent)
Create a new PathMetadata for collection any access
|
static <T> PathMetadata<T> |
PathMetadataFactory.forDelegate(Path<T> delegate)
Create a new PathMetadata for delegate access
|
static PathMetadata<Integer> |
PathMetadataFactory.forListAccess(Path<?> parent,
Expression<Integer> index)
Create a new PathMetadata for indexed list access
|
static PathMetadata<Integer> |
PathMetadataFactory.forListAccess(Path<?> parent,
int index)
Create a new PathMetadata for indexed list access
|
static <KT> PathMetadata<KT> |
PathMetadataFactory.forMapAccess(Path<?> parent,
Expression<KT> key)
Create a new PathMetadata for key based map access
|
static <KT> PathMetadata<KT> |
PathMetadataFactory.forMapAccess(Path<?> parent,
KT key)
Create a new PathMetadata for for key based map access
|
static PathMetadata<String> |
PathMetadataFactory.forProperty(Path<?> parent,
String property)
Create a new PathMetadata for property access
|
R |
Visitor.visit(Path<?> expr,
C context) |
Void |
ParamsVisitor.visit(Path<?> expr,
QueryMetadata context) |
Set<Expression<?>> |
ValidatingVisitor.visit(Path<?> expr,
Set<Expression<?>> known) |
String |
ToStringVisitor.visit(Path<?> p,
Templates templates) |
Path<?> |
PathExtractor.visit(Path<?> expr,
Void context) |
Integer |
HashCodeVisitor.visit(Path<?> expr,
Void context) |
Constructor and Description |
---|
PathImpl(Class<? extends T> type,
Path<?> parent,
String property) |
PathMetadata(Path<?> parent,
Object element,
PathType type) |
QBean(Path<T> type,
boolean fieldAccess,
Expression<?>... args)
Create a new QBean instance
|
QBean(Path<T> type,
boolean fieldAccess,
Map<String,? extends Expression<?>> bindings)
Create a new QBean instance
|
QBean(Path<T> type,
Expression<?>... args)
Create a new QBean instance
|
QBean(Path<T> type,
Map<String,? extends Expression<?>> bindings)
Create a new QBean instance
|
Modifier and Type | Method and Description |
---|---|
BooleanExpression |
BooleanExpression.as(Path<Boolean> alias) |
StringExpression |
StringExpression.as(Path<String> alias) |
SimpleExpression<T> |
SimpleExpression.as(Path<T> alias)
Create an alias for the expression
|
DateTimeExpression<T> |
DateTimeExpression.as(Path<T> alias) |
DateExpression<T> |
DateExpression.as(Path<T> alias) |
DslExpression<T> |
DslExpression.as(Path<T> alias)
Create an alias for the expression
|
TimeExpression<T> |
TimeExpression.as(Path<T> alias) |
ComparableExpression<T> |
ComparableExpression.as(Path<T> alias) |
DslExpression<T> |
Coalesce.as(Path<T> alias)
Create an alias for the expression
|
NumberExpression<T> |
NumberExpression.as(Path<T> alias) |
EnumExpression<T> |
EnumExpression.as(Path<T> alias) |
Modifier and Type | Class and Description |
---|---|
class |
ArrayPath<A,E>
ArrayPath represents an array typed path
|
class |
BeanPath<T>
BeanPath represents bean paths
|
class |
BooleanPath
BooleanPath represents boolean path expressions
|
class |
CollectionPath<E,Q extends SimpleExpression<? super E>>
CollectionPath represents collection paths
|
class |
CollectionPathBase<C extends Collection<E>,E,Q extends SimpleExpression<? super E>>
CollectionPath is a base class for collection typed paths
|
class |
ComparableEntityPath<T extends Comparable>
ComparableEntityPath extends the ComparablePath class to implement the EntityPath interface
|
class |
ComparablePath<T extends Comparable>
ComparablePath represents Comparable paths
|
class |
DatePath<T extends Comparable>
DatePath presents Date paths
|
class |
DateTimePath<T extends Comparable>
DateTimePath presents DateTime typed paths
|
class |
DslPath<T>
DslPath represents simple paths
|
class |
EntityPathBase<T>
EntityPathBase provides a base class for EntityPath implementations
|
class |
EnumPath<T extends Enum<T>>
EnumPath represents enum paths
|
class |
ListPath<E,Q extends SimpleExpression<? super E>>
ListPath represents list paths
|
class |
MapPath<K,V,E extends SimpleExpression<? super V>>
MapPath represents map paths
|
class |
NumberPath<T extends Number & Comparable<?>>
NumberPath represents numeric paths
|
class |
PathBuilder<T>
PathBuilder is an extension to EntityPathBase for dynamic path construction
|
class |
SetPath<E,Q extends SimpleExpression<? super E>>
SetPath represents set paths
|
class |
SimplePath<T>
SimplePath represents simple paths
|
class |
StringPath
StringPath represents String typed paths
|
class |
TimePath<T extends Comparable>
TimePath represented Time paths
|
Modifier and Type | Method and Description |
---|---|
protected <P extends Path<?>> |
BeanPath.add(P path)
Template method for tracking child path creation
|
Modifier and Type | Method and Description |
---|---|
Path<?> |
SimplePath.getRoot() |
Path<?> |
StringPath.getRoot() |
Path<?> |
MapPath.getRoot() |
Path<?> |
SetPath.getRoot() |
Path<?> |
ComparablePath.getRoot() |
Path<?> |
ArrayPath.getRoot() |
Path<?> |
DatePath.getRoot() |
Path<?> |
NumberPath.getRoot() |
Path<?> |
ListPath.getRoot() |
Path<?> |
CollectionPath.getRoot() |
Path<?> |
BooleanPath.getRoot() |
Path<?> |
DslPath.getRoot() |
Path<?> |
EnumPath.getRoot() |
Path<?> |
DateTimePath.getRoot() |
Path<?> |
TimePath.getRoot() |
Path<?> |
BeanPath.getRoot() |
Modifier and Type | Method and Description |
---|---|
<A> SimplePath<A> |
PathBuilder.get(Path<A> path) |
Constructor and Description |
---|
ArrayPath(Class<? super A> type,
Path<?> parent,
String property) |
BeanPath(Class<? extends T> type,
Path<?> parent,
String property) |
BooleanPath(Path<?> parent,
String property) |
CollectionPath(Class<? super E> type,
Class<Q> queryType,
Path<?> parent,
String property) |
ComparableEntityPath(Class<? extends T> type,
Path<?> parent,
String property) |
ComparablePath(Class<? extends T> type,
Path<?> parent,
String property) |
DatePath(Class<? extends T> type,
Path<?> parent,
String property) |
DateTimePath(Class<? extends T> type,
Path<?> parent,
String property) |
DslPath(Class<? extends T> type,
Path<?> parent,
String property) |
EnumPath(Class<? extends T> type,
Path<?> parent,
String property) |
ListPath(Class<? super E> elementType,
Class<Q> queryType,
Path<?> parent,
String property) |
MapPath(Class<? super K> keyType,
Class<? super V> valueType,
Class<E> queryType,
Path<?> parent,
String property) |
NumberPath(Class<? extends T> type,
Path<?> parent,
String property) |
SetPath(Class<? super E> type,
Class<Q> queryType,
Path<?> parent,
String property) |
SimplePath(Class<? extends T> type,
Path<?> parent,
String property) |
StringPath(Path<?> parent,
String property) |
TimePath(Class<? extends T> type,
Path<?> parent,
String property) |
Copyright © 2007-2013 Mysema Ltd. All Rights Reserved.