|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Path | |
---|---|
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.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.impl | HQL Support classes |
com.mysema.query.lucene | |
com.mysema.query.mongodb | |
com.mysema.query.mongodb.morphia | |
com.mysema.query.search | |
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 |
Uses of Path in com.mysema.query.alias |
---|
Methods in com.mysema.query.alias that return Path | ||
---|---|---|
|
PathFactory.createArrayPath(Class<T[]> type,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createArrayPath(Class<T[]> arrayType,
PathMetadata<?> metadata)
|
|
Path<Boolean> |
PathFactory.createBooleanPath(PathMetadata<?> metadata)
|
|
Path<Boolean> |
DefaultPathFactory.createBooleanPath(PathMetadata<?> metadata)
|
|
|
PathFactory.createCollectionPath(Class<E> elementType,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createCollectionPath(Class<E> elementType,
PathMetadata<?> metadata)
|
|
|
PathFactory.createComparablePath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createComparablePath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
PathFactory.createDatePath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createDatePath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
PathFactory.createDateTimePath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createDateTimePath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
PathFactory.createEntityPath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createEntityPath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
PathFactory.createEnumPath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createEnumPath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
PathFactory.createListPath(Class<E> elementType,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createListPath(Class<E> elementType,
PathMetadata<?> metadata)
|
|
|
PathFactory.createMapPath(Class<K> keyType,
Class<V> valueType,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createMapPath(Class<K> keyType,
Class<V> valueType,
PathMetadata<?> metadata)
|
|
|
PathFactory.createNumberPath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createNumberPath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
PathFactory.createSetPath(Class<E> elementType,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createSetPath(Class<E> elementType,
PathMetadata<?> metadata)
|
|
|
PathFactory.createSimplePath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createSimplePath(Class<T> type,
PathMetadata<?> metadata)
|
|
Path<String> |
PathFactory.createStringPath(PathMetadata<?> metadata)
|
|
Path<String> |
DefaultPathFactory.createStringPath(PathMetadata<?> metadata)
|
|
|
PathFactory.createTimePath(Class<T> type,
PathMetadata<?> metadata)
|
|
|
DefaultPathFactory.createTimePath(Class<T> type,
PathMetadata<?> metadata)
|
Uses of Path in com.mysema.query.codegen |
---|
Method parameters in com.mysema.query.codegen with type arguments of type Path | |
---|---|
void |
TypeMappings.register(com.mysema.codegen.model.TypeCategory category,
Class<? extends Expression> expr,
Class<? extends Path> path,
Class<? extends TemplateExpression> template)
|
Uses of Path in com.mysema.query.collections |
---|
Methods in com.mysema.query.collections with parameters of type Path | ||
---|---|---|
|
ColQuery.bind(Path<A> entity,
Iterable<? extends A> col)
Bind the given collection to an already existing query source |
|
|
AbstractColQuery.bind(Path<A> entity,
Iterable<? extends A> col)
|
|
static
|
MiniApi.delete(Path<A> path,
Collection<A> col)
|
|
static
|
MiniApi.from(Path<A> path,
A... arr)
|
|
|
ColQuery.from(Path<A> entity,
Iterable<? extends A> col)
Add a query source |
|
|
AbstractColQuery.from(Path<A> entity,
Iterable<? extends A> col)
|
|
static
|
MiniApi.from(Path<A> path,
Iterable<A> col)
|
|
|
ColQuery.innerJoin(CollectionExpression<?,P> collectionPath,
Path<P> alias)
Define an inner join from the Collection typed path to the alias |
|
|
AbstractColQuery.innerJoin(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
ColQuery.innerJoin(MapExpression<?,P> mapPath,
Path<P> alias)
Define an inner join from the Map typed path to the alias |
|
|
AbstractColQuery.innerJoin(MapExpression<?,P> target,
Path<P> alias)
|
|
|
ColUpdateClause.set(Path<U> path,
Expression<? extends U> expression)
|
|
|
ColUpdateClause.set(Path<U> path,
U value)
|
|
|
ColUpdateClause.setNull(Path<U> path)
|
|
static
|
MiniApi.update(Path<A> path,
Iterable<A> col)
|
|
Void |
ColQuerySerializer.visit(Path<?> path,
Void context)
|
Method parameters in com.mysema.query.collections with type arguments of type Path | |
---|---|
ColUpdateClause<T> |
ColUpdateClause.set(List<? extends Path<?>> p,
List<?> v)
|
Constructors in com.mysema.query.collections with parameters of type Path | |
---|---|
ColDeleteClause(Path<T> expr,
Collection<? extends T> col)
|
|
ColDeleteClause(QueryEngine qe,
Path<T> expr,
Collection<? extends T> col)
|
|
ColUpdateClause(Path<T> expr,
Iterable<? extends T> col)
|
|
ColUpdateClause(QueryEngine qe,
Path<T> expr,
Iterable<? extends T> col)
|
Uses of Path in com.mysema.query.dml |
---|
Methods in com.mysema.query.dml with parameters of type Path | ||
---|---|---|
C |
InsertClause.columns(Path<?>... columns)
Define the columns to be populated |
|
|
StoreClause.set(Path<T> path,
Expression<? extends T> expression)
Add an expression binding |
|
|
StoreClause.set(Path<T> path,
T value)
Add a value binding |
|
|
StoreClause.setNull(Path<T> path)
Bind the given path to null |
Method parameters in com.mysema.query.dml with type arguments of type Path | |
---|---|
C |
UpdateClause.set(List<? extends Path<?>> paths,
List<?> values)
Set the paths to be updated |
Uses of Path in com.mysema.query.jdo |
---|
Methods in com.mysema.query.jdo with parameters of type Path | |
---|---|
Void |
JDOQLSerializer.visit(Path<?> path,
Void context)
|
Uses of Path in com.mysema.query.jdo.dml |
---|
Methods in com.mysema.query.jdo.dml with parameters of type Path | ||
---|---|---|
|
JDOQLUpdateClause.set(Path<T> path,
Expression<? extends T> expression)
|
|
|
JDOQLUpdateClause.set(Path<T> path,
T value)
|
|
|
JDOQLUpdateClause.setNull(Path<T> path)
|
Method parameters in com.mysema.query.jdo.dml with type arguments of type Path | |
---|---|
JDOQLUpdateClause |
JDOQLUpdateClause.set(List<? extends Path<?>> paths,
List<?> values)
|
Uses of Path in com.mysema.query.jdo.sql |
---|
Methods in com.mysema.query.jdo.sql with parameters of type Path | |
---|---|
T |
AbstractSQLQuery.from(SubQueryExpression<?> subQuery,
Path<?> alias)
|
T |
AbstractSQLQuery.fullJoin(SubQueryExpression<?> o,
Path<?> alias)
|
T |
AbstractSQLQuery.innerJoin(SubQueryExpression<?> o,
Path<?> alias)
|
T |
AbstractSQLQuery.join(SubQueryExpression<?> o,
Path<?> alias)
|
T |
AbstractSQLQuery.leftJoin(SubQueryExpression<?> o,
Path<?> alias)
|
T |
AbstractSQLQuery.rightJoin(SubQueryExpression<?> o,
Path<?> alias)
|
Uses of Path in com.mysema.query.jpa |
---|
Methods in com.mysema.query.jpa that return types with arguments of type Path | |
---|---|
List<Path<?>> |
NativeSQLSerializer.getEntityPaths()
|
Methods in com.mysema.query.jpa with parameters of type Path | ||
---|---|---|
T |
AbstractSQLQuery.from(SubQueryExpression<?> subQuery,
Path<?> alias)
|
|
|
AbstractJPQLSubQuery.fullJoin(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLQueryBase.fullJoin(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLCommonQuery.fullJoin(CollectionExpression<?,P> target,
Path<P> alias)
Create a full join with the given target and alias. |
|
|
AbstractJPQLSubQuery.fullJoin(MapExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLQueryBase.fullJoin(MapExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLCommonQuery.fullJoin(MapExpression<?,P> target,
Path<P> alias)
Create a full join with the given target and alias. |
|
T |
AbstractSQLQuery.fullJoin(SubQueryExpression<?> o,
Path<?> alias)
|
|
|
AbstractJPQLSubQuery.innerJoin(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLQueryBase.innerJoin(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLCommonQuery.innerJoin(CollectionExpression<?,P> target,
Path<P> alias)
Create an inner join with the given target and alias. |
|
|
AbstractJPQLSubQuery.innerJoin(MapExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLQueryBase.innerJoin(MapExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLCommonQuery.innerJoin(MapExpression<?,P> target,
Path<P> alias)
Create an inner join with the given target and alias. |
|
T |
AbstractSQLQuery.innerJoin(SubQueryExpression<?> o,
Path<?> alias)
|
|
|
AbstractJPQLSubQuery.join(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLQueryBase.join(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLCommonQuery.join(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
AbstractJPQLSubQuery.join(MapExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLQueryBase.join(MapExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLCommonQuery.join(MapExpression<?,P> target,
Path<P> alias)
Create a join with the given target and alias. |
|
T |
AbstractSQLQuery.join(SubQueryExpression<?> o,
Path<?> alias)
|
|
|
AbstractJPQLSubQuery.leftJoin(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLQueryBase.leftJoin(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLCommonQuery.leftJoin(CollectionExpression<?,P> target,
Path<P> alias)
Create a left join with the given target and alias. |
|
|
AbstractJPQLSubQuery.leftJoin(MapExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLQueryBase.leftJoin(MapExpression<?,P> target,
Path<P> alias)
|
|
|
JPQLCommonQuery.leftJoin(MapExpression<?,P> target,
Path<P> alias)
Create a left join with the given target and alias. |
|
T |
AbstractSQLQuery.leftJoin(SubQueryExpression<?> o,
Path<?> alias)
|
|
T |
AbstractSQLQuery.rightJoin(SubQueryExpression<?> o,
Path<?> alias)
|
|
Void |
NativeSQLSerializer.visit(Path<?> path,
Void context)
|
|
Void |
JPQLSerializer.visit(Path<?> expr,
Void context)
|
Uses of Path in com.mysema.query.jpa.hibernate |
---|
Methods in com.mysema.query.jpa.hibernate with parameters of type Path | ||
---|---|---|
|
HibernateUpdateClause.set(Path<T> path,
Expression<? extends T> expression)
|
|
|
HibernateUpdateClause.set(Path<T> path,
T value)
|
|
Q |
AbstractHibernateQuery.setLockMode(Path<?> path,
org.hibernate.LockMode lockMode)
Set the lock mode for the given path. |
|
|
HibernateUpdateClause.setNull(Path<T> path)
|
Method parameters in com.mysema.query.jpa.hibernate with type arguments of type Path | |
---|---|
HibernateUpdateClause |
HibernateUpdateClause.set(List<? extends Path<?>> paths,
List<?> values)
|
Uses of Path in com.mysema.query.jpa.impl |
---|
Methods in com.mysema.query.jpa.impl with parameters of type Path | ||
---|---|---|
|
JPAUpdateClause.set(Path<T> path,
Expression<? extends T> expression)
|
|
|
JPAUpdateClause.set(Path<T> path,
T value)
|
|
|
JPAUpdateClause.setNull(Path<T> path)
|
Method parameters in com.mysema.query.jpa.impl with type arguments of type Path | |
---|---|
JPAUpdateClause |
JPAUpdateClause.set(List<? extends Path<?>> paths,
List<?> values)
|
Uses of Path in com.mysema.query.lucene |
---|
Methods in com.mysema.query.lucene with parameters of type Path | |
---|---|
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 |
LuceneUtils.fuzzyLike(Path<String> path,
String value)
Create a fuzzy query |
static BooleanExpression |
LuceneUtils.fuzzyLike(Path<String> path,
String value,
float minimumSimilarity)
Create a fuzzy query |
static BooleanExpression |
LuceneUtils.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 |
Uses of Path in com.mysema.query.mongodb |
---|
Classes in com.mysema.query.mongodb that implement Path | |
---|---|
class |
Point
Point is an adapter type for Double[] arrays to use geo spatial querying features of Mongodb |
Methods in com.mysema.query.mongodb with parameters of type Path | |
---|---|
protected String |
MongodbSerializer.getKeyForPath(Path<?> expr,
PathMetadata<?> metadata)
|
Object |
MongodbSerializer.visit(Path<?> expr,
Void context)
|
Constructors in com.mysema.query.mongodb with parameters of type Path | |
---|---|
Point(Path<?> parent,
String property)
|
Uses of Path in com.mysema.query.mongodb.morphia |
---|
Methods in com.mysema.query.mongodb.morphia with parameters of type Path | |
---|---|
protected String |
MorphiaSerializer.getKeyForPath(Path<?> expr,
PathMetadata<?> metadata)
|
Uses of Path in com.mysema.query.search |
---|
Methods in com.mysema.query.search with parameters of type Path | |
---|---|
String |
SearchSerializer.toField(Path<?> path)
|
Uses of Path in com.mysema.query.sql |
---|
Subinterfaces of Path in com.mysema.query.sql | |
---|---|
interface |
RelationalPath<T>
RelationalPath extends EntityPath to provide access to relational metadata |
Classes in com.mysema.query.sql that implement Path | |
---|---|
class |
RelationalPathBase<T>
RelationalPathBase is a base class for RelationPath implements |
Methods in com.mysema.query.sql with type parameters of type Path | ||
---|---|---|
protected
|
RelationalPathBase.add(P path)
|
Methods in com.mysema.query.sql that return Path | |
---|---|
Path<?>[] |
RelationalPathBase.all()
|
Methods in com.mysema.query.sql that return types with arguments of type Path | |
---|---|
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()
|
Methods in com.mysema.query.sql with parameters of type Path | ||
---|---|---|
protected
|
RelationalPathBase.createForeignKey(Path<?> local,
String foreign)
|
|
protected
|
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 |
|
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 |
|
|
Configuration.get(ResultSet rs,
Path<?> path,
int i,
Class<T> clazz)
|
|
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 |
|
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 |
|
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 |
|
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 |
|
|
Configuration.set(PreparedStatement stmt,
Path<?> path,
int i,
T value)
|
|
Void |
SQLSerializer.visit(Path<?> path,
Void context)
|
Method parameters in com.mysema.query.sql with type arguments of type Path | ||
---|---|---|
protected
|
RelationalPathBase.createForeignKey(List<? extends Path<?>> local,
List<String> foreign)
|
|
protected
|
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)
|
Constructors in com.mysema.query.sql with parameters of type Path | |
---|---|
ForeignKey(RelationalPath<?> entity,
Path<?> localColumn,
String foreignColumn)
|
|
PrimaryKey(RelationalPath<?> entity,
Path<?>... localColumns)
|
Constructor parameters in com.mysema.query.sql with type arguments of type Path | |
---|---|
ForeignKey(RelationalPath<?> entity,
List<? extends Path<?>> localColumns,
List<String> foreignColumns)
|
|
PrimaryKey(RelationalPath<?> entity,
List<? extends Path<?>> localColumns)
|
Uses of Path in com.mysema.query.sql.dml |
---|
Methods in com.mysema.query.sql.dml that return types with arguments of type Path | |
---|---|
List<Path<?>> |
SQLMergeBatch.getColumns()
|
List<Path<?>> |
SQLInsertBatch.getColumns()
|
List<Path<?>> |
SQLMergeBatch.getKeys()
|
Methods in com.mysema.query.sql.dml with parameters of type Path | ||
---|---|---|
SQLMergeClause |
SQLMergeClause.columns(Path<?>... columns)
|
|
SQLInsertClause |
SQLInsertClause.columns(Path<?>... columns)
|
|
|
SQLInsertClause.executeWithKey(Path<T> path)
Execute the clause and return the generated key with the type of the given path If no rows were created, null is returned, otherwise the key of the first row is returned. |
|
|
SQLInsertClause.executeWithKeys(Path<T> path)
Execute the clause and return the generated keys with the type of the given path. |
|
SQLMergeClause |
SQLMergeClause.keys(Path<?>... paths)
Set the keys to be used in the MERGE clause |
|
|
SQLMergeClause.set(Path<T> path,
Expression<? extends T> expression)
|
|
|
SQLInsertClause.set(Path<T> path,
Expression<? extends T> expression)
|
|
|
SQLUpdateClause.set(Path<T> path,
Expression<? extends T> expression)
|
|
|
SQLMergeClause.set(Path<T> path,
T value)
|
|
|
SQLInsertClause.set(Path<T> path,
T value)
|
|
|
SQLUpdateClause.set(Path<T> path,
T value)
|
|
|
SQLMergeClause.setNull(Path<T> path)
|
|
|
SQLInsertClause.setNull(Path<T> path)
|
|
|
SQLUpdateClause.setNull(Path<T> path)
|
Method parameters in com.mysema.query.sql.dml with type arguments of type Path | |
---|---|
SQLUpdateClause |
SQLUpdateClause.set(List<? extends Path<?>> paths,
List<?> values)
|
protected void |
AbstractSQLClause.setParameters(PreparedStatement stmt,
List<?> objects,
List<Path<?>> constantPaths,
Map<Param<?>,?> params)
Set the parameters to the given PreparedStatement |
Constructor parameters in com.mysema.query.sql.dml with type arguments of type Path | |
---|---|
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)
|
Uses of Path in com.mysema.query.support |
---|
Fields in com.mysema.query.support with type parameters of type Path | |
---|---|
List<Path<?>> |
Context.paths
|
Methods in com.mysema.query.support with parameters of type Path | ||
---|---|---|
void |
Context.add(Path<?> anyPath,
EntityPath<?> replacement)
|
|
static BooleanPath |
Expressions.booleanPath(Path<?> parent,
String property)
|
|
static
|
Expressions.comparablePath(Class<T> type,
Path<?> parent,
String property)
|
|
protected
|
QueryMixin.createAlias(CollectionExpression<?,D> target,
Path<D> alias)
|
|
protected
|
QueryMixin.createAlias(Expression<D> path,
Path<D> alias)
|
|
protected
|
QueryMixin.createAlias(MapExpression<?,D> target,
Path<D> alias)
|
|
protected
|
QueryMixin.createAlias(SubQueryExpression<D> path,
Path<D> alias)
|
|
static
|
Expressions.datePath(Class<T> type,
Path<?> parent,
String property)
|
|
static
|
Expressions.dateTimePath(Class<T> type,
Path<?> parent,
String property)
|
|
|
QueryMixin.fullJoin(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
QueryMixin.fullJoin(MapExpression<?,P> target,
Path<P> alias)
|
|
|
QueryMixin.fullJoin(SubQueryExpression<P> target,
Path alias)
|
|
|
QueryMixin.innerJoin(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
QueryMixin.innerJoin(MapExpression<?,P> target,
Path<P> alias)
|
|
|
QueryMixin.innerJoin(SubQueryExpression<P> target,
Path alias)
|
|
|
QueryMixin.join(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
QueryMixin.join(MapExpression<?,P> target,
Path<P> alias)
|
|
|
QueryMixin.join(SubQueryExpression<P> target,
Path alias)
|
|
|
QueryMixin.leftJoin(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
QueryMixin.leftJoin(MapExpression<?,P> target,
Path<P> alias)
|
|
|
QueryMixin.leftJoin(SubQueryExpression<P> target,
Path alias)
|
|
static
|
Expressions.numberPath(Class<T> type,
Path<?> parent,
String property)
|
|
static
|
Expressions.path(Class<T> type,
Path<?> parent,
String property)
|
|
|
QueryMixin.rightJoin(CollectionExpression<?,P> target,
Path<P> alias)
|
|
|
QueryMixin.rightJoin(MapExpression<?,P> target,
Path<P> alias)
|
|
|
QueryMixin.rightJoin(SubQueryExpression<P> target,
Path alias)
|
|
static StringPath |
Expressions.stringPath(Path<?> parent,
String property)
|
|
static
|
Expressions.timePath(Class<T> type,
Path<?> parent,
String property)
|
|
Expression<?> |
CollectionAnyVisitor.visit(Path<?> expr,
Context context)
|
|
Expression<?> |
ListAccessVisitor.visit(Path<?> expr,
Context context)
|
|
Void |
SerializerBase.visit(Path<?> path,
Void context)
|
Uses of Path in com.mysema.query.types |
---|
Subinterfaces of Path in com.mysema.query.types | |
---|---|
interface |
EntityPath<T>
EntityPath is the common interface for entity path expressions |
Classes in com.mysema.query.types that implement Path | |
---|---|
class |
PathImpl<T>
PathImpl defines a default implementation of the Path interface |
Methods in com.mysema.query.types that return Path | |
---|---|
Path<?> |
PathMetadata.getParent()
|
Path<?> |
Path.getRoot()
Get the root for this path |
Path<?> |
PathImpl.getRoot()
|
Path<?> |
PathMetadata.getRoot()
|
Methods in com.mysema.query.types with parameters of type Path | ||
---|---|---|
static
|
ExpressionUtils.as(Expression<D> source,
Path<D> alias)
Create an alias expression (source as alias) with the given source and alias |
|
static
|
Projections.bean(Path<T> type,
Expression<?>... exprs)
Create a Bean populating projection for the given type and expressions |
|
static
|
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)
|
|
static PathMetadata<Integer> |
PathMetadataFactory.forArrayAccess(Path<?> parent,
int index)
|
|
static PathMetadata<?> |
PathMetadataFactory.forCollectionAny(Path<?> parent)
|
|
static PathMetadata<Integer> |
PathMetadataFactory.forListAccess(Path<?> parent,
Expression<Integer> index)
|
|
static PathMetadata<Integer> |
PathMetadataFactory.forListAccess(Path<?> parent,
int index)
|
|
static
|
PathMetadataFactory.forMapAccess(Path<?> parent,
Expression<KT> key)
|
|
static
|
PathMetadataFactory.forMapAccess(Path<?> parent,
KT key)
|
|
static PathMetadata<String> |
PathMetadataFactory.forProperty(Path<?> parent,
String property)
|
|
R |
Visitor.visit(Path<?> expr,
C context)
|
|
String |
ToStringVisitor.visit(Path<?> p,
Templates templates)
|
|
Expression<?> |
ExtractorVisitor.visit(Path<?> expr,
Void context)
|
|
Void |
ValidatingVisitor.visit(Path<?> expr,
Void context)
|
Constructors in com.mysema.query.types with parameters of type Path | |
---|---|
PathMetadata(Path<?> parent,
Expression<T> expression,
PathType type)
|
|
QBean(Path<T> type,
boolean fieldAccess,
Expression<?>... args)
|
|
QBean(Path<T> type,
boolean fieldAccess,
Map<String,? extends Expression<?>> bindings)
|
|
QBean(Path<T> type,
Expression<?>... args)
|
|
QBean(Path<T> type,
Map<String,? extends Expression<?>> bindings)
|
Uses of Path in com.mysema.query.types.expr |
---|
Methods in com.mysema.query.types.expr with parameters of type Path | |
---|---|
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)
|
TimeExpression<T> |
TimeExpression.as(Path<T> alias)
|
ComparableExpression<T> |
ComparableExpression.as(Path<T> alias)
|
NumberExpression<T> |
NumberExpression.as(Path<T> alias)
|
EnumExpression<T> |
EnumExpression.as(Path<T> alias)
|
Uses of Path in com.mysema.query.types.path |
---|
Classes in com.mysema.query.types.path that implement 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 Path | ||
---|---|---|
protected
|
BeanPath.add(P path)
Template method for tracking child path creation |
Methods in com.mysema.query.types.path that return Path | |
---|---|
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<?> |
EnumPath.getRoot()
|
Path<?> |
DateTimePath.getRoot()
|
Path<?> |
TimePath.getRoot()
|
Path<?> |
BeanPath.getRoot()
|
Methods in com.mysema.query.types.path with parameters of type Path | ||
---|---|---|
|
PathBuilder.get(Path<A> path)
|
Constructors in com.mysema.query.types.path with parameters of type Path | |
---|---|
ArrayPath(Class<? super E[]> 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)
|
|
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)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |