Uses of Interface
com.mysema.query.types.Path

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

<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<?>> Path<T>	PathFactory.createComparablePath(Class<T> type, PathMetadata<?> metadata)
<T extends Comparable<?>> Path<T>	DefaultPathFactory.createComparablePath(Class<T> type, PathMetadata<?> metadata)
<T extends Comparable<?>> Path<T>	PathFactory.createDatePath(Class<T> type, PathMetadata<?> metadata)
<T extends Comparable<?>> Path<T>	DefaultPathFactory.createDatePath(Class<T> type, PathMetadata<?> metadata)
<T extends Comparable<?>> Path<T>	PathFactory.createDateTimePath(Class<T> type, PathMetadata<?> metadata)
<T extends Comparable<?>> Path<T>	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>> Path<T>	PathFactory.createEnumPath(Class<T> type, PathMetadata<?> metadata)
<T extends Enum<T>> Path<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>> Path<T>	PathFactory.createNumberPath(Class<T> type, PathMetadata<?> metadata)
<T extends Number & Comparable<T>> Path<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<?>> Path<T>	PathFactory.createTimePath(Class<T> type, PathMetadata<?> metadata)
<T extends Comparable<?>> Path<T>	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

static <A> ColDeleteClause<A>	MiniApi.delete(Path<A> path, Collection<A> col)
static <A> ColQuery	MiniApi.from(Path<A> path, A... arr)
<A> ColQuery	ColQuery.from(Path<A> entity, Iterable<? extends A> col) Add a query source
<A> Q	AbstractColQuery.from(Path<A> entity, Iterable<? extends A> col)
static <A> ColQuery	MiniApi.from(Path<A> path, Iterable<A> col)
<P> ColQuery	ColQuery.innerJoin(CollectionExpression<?,P> collectionPath, Path<P> alias) Define an inner join from the Collection typed path to the alias
<P> Q	AbstractColQuery.innerJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> ColQuery	ColQuery.innerJoin(MapExpression<?,P> mapPath, Path<P> alias) Define an inner join from the Map typed path to the alias
<P> Q	AbstractColQuery.innerJoin(MapExpression<?,P> target, Path<P> alias)
<U> ColUpdateClause<T>	ColUpdateClause.set(Path<U> path, Expression<? extends U> expression)
<U> ColUpdateClause<T>	ColUpdateClause.set(Path<U> path, U value)
<U> ColUpdateClause<T>	ColUpdateClause.setNull(Path<U> path)
static <A> ColUpdateClause<A>	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
<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

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

<T> JDOQLUpdateClause	JDOQLUpdateClause.set(Path<T> path, Expression<? extends T> expression)
<T> JDOQLUpdateClause	JDOQLUpdateClause.set(Path<T> path, T value)
<T> JDOQLUpdateClause	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<?>>

HibernateSQLSerializer.getEntityPaths()

Methods in com.mysema.query.jpa with parameters of type Path

T	AbstractSQLQuery.from(SubQueryExpression<?> subQuery, Path<?> alias)
<P> Q	AbstractJPQLSubQuery.fullJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> Q	JPQLQueryBase.fullJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> Q	JPQLCommonQuery.fullJoin(CollectionExpression<?,P> target, Path<P> alias) Create a full join with the given target and alias.
<P> Q	AbstractJPQLSubQuery.fullJoin(MapExpression<?,P> target, Path<P> alias)
<P> Q	JPQLQueryBase.fullJoin(MapExpression<?,P> target, Path<P> alias)
<P> Q	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)
<P> Q	AbstractJPQLSubQuery.innerJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> Q	JPQLQueryBase.innerJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> Q	JPQLCommonQuery.innerJoin(CollectionExpression<?,P> target, Path<P> alias) Create an inner join with the given target and alias.
<P> Q	AbstractJPQLSubQuery.innerJoin(MapExpression<?,P> target, Path<P> alias)
<P> Q	JPQLQueryBase.innerJoin(MapExpression<?,P> target, Path<P> alias)
<P> Q	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)
<P> Q	AbstractJPQLSubQuery.join(CollectionExpression<?,P> target, Path<P> alias)
<P> Q	JPQLQueryBase.join(CollectionExpression<?,P> target, Path<P> alias)
<P> Q	JPQLCommonQuery.join(CollectionExpression<?,P> target, Path<P> alias)
<P> Q	AbstractJPQLSubQuery.join(MapExpression<?,P> target, Path<P> alias)
<P> Q	JPQLQueryBase.join(MapExpression<?,P> target, Path<P> alias)
<P> Q	JPQLCommonQuery.join(MapExpression<?,P> target, Path<P> alias) Create a join with the given target and alias.
T	AbstractSQLQuery.join(SubQueryExpression<?> o, Path<?> alias)
<P> Q	AbstractJPQLSubQuery.leftJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> Q	JPQLQueryBase.leftJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> Q	JPQLCommonQuery.leftJoin(CollectionExpression<?,P> target, Path<P> alias) Create a left join with the given target and alias.
<P> Q	AbstractJPQLSubQuery.leftJoin(MapExpression<?,P> target, Path<P> alias)
<P> Q	JPQLQueryBase.leftJoin(MapExpression<?,P> target, Path<P> alias)
<P> Q	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	HibernateSQLSerializer.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

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

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

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

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

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
String	LuceneSerializer.toField(Path<?> path)

Uses of Path in com.mysema.query.mongodb

Methods in com.mysema.query.mongodb with parameters of type Path

Object

MongodbSerializer.visit(Path<?> expr, Void context)

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 <P extends Path<?>> P

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 <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
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)
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
<T> int	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 <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)

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)
<T> T	SQLInsertClause.executeWithKey(Path<T> path)
<T> List<T>	SQLInsertClause.executeWithKeys(Path<T> path)
SQLMergeClause	SQLMergeClause.keys(Path<?>... paths)
<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)

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)

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

CollectionAnyVisitor.Context.anyPaths

Methods in com.mysema.query.support with parameters of type Path

void	CollectionAnyVisitor.Context.add(Path<?> anyPath, EntityPath<?> replacement)
protected <D> Expression<D>	QueryMixin.createAlias(CollectionExpression<?,D> target, Path<D> alias)
protected <D> Expression<D>	QueryMixin.createAlias(Expression<D> path, Path<D> alias)
protected <D> Expression<D>	QueryMixin.createAlias(MapExpression<?,D> target, Path<D> alias)
protected <D> Expression<D>	QueryMixin.createAlias(SubQueryExpression<D> path, Path<D> alias)
<P> T	QueryMixin.fullJoin(CollectionExpression<?,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(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(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(MapExpression<?,P> target, Path<P> alias)
<P> T	QueryMixin.leftJoin(SubQueryExpression<P> target, Path alias)
<P> T	QueryMixin.rightJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> T	QueryMixin.rightJoin(MapExpression<?,P> target, Path<P> alias)
<P> T	QueryMixin.rightJoin(SubQueryExpression<P> target, Path alias)
Expression<?>	CollectionAnyVisitor.visit(Path<?> expr, CollectionAnyVisitor.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 <D> Expression<D>	ExpressionUtils.as(Expression<D> source, Path<D> alias)
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 <KT> PathMetadata<KT>	PathMetadataFactory.forMapAccess(Path<?> parent, Expression<KT> key)
static <KT> PathMetadata<KT>	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)

Constructors in com.mysema.query.types with parameters of type Path

PathMetadata(Path<?> parent, Expression<T> expression, PathType type)

QBean(Path<T> type, Expression<?>... args)

QBean(Path<T> type, Map<String,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)
SimpleExpression<D>	SimpleExpression.as(Path<D> alias) Create an alias for the expression
DateTimeExpression<D>	DateTimeExpression.as(Path<D> alias)
DateExpression<D>	DateExpression.as(Path<D> alias)
TimeExpression<D>	TimeExpression.as(Path<D> alias)
ComparableExpression<D>	ComparableExpression.as(Path<D> alias)
NumberExpression<D>	NumberExpression.as(Path<D> alias)
StringExpression	StringExpression.as(Path<String> 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<D> BeanPath represents bean paths
class	BooleanPath BooleanPath represents boolean path expressions
class	CollectionPath<E,Q extends SimpleExpression<E>> CollectionPath represents collection paths
class	CollectionPathBase<C extends Collection<E>,E,Q extends SimpleExpression<E>> CollectionPath is a base class for collection typed paths
class	ComparablePath<D extends Comparable> ComparablePath represents Comparable paths
class	DatePath<D extends Comparable> DatePath presents Date paths
class	DateTimePath<D extends Comparable> DateTimePath presents DateTime typed paths
class	EntityPathBase<D> EntityPathBase provides a base class for EntityPath implementations
class	EnumPath<D extends Enum<D>> EnumPath represents enum paths
class	ListPath<E,Q extends SimpleExpression<E>> ListPath represents list paths
class	MapPath<K,V,E extends SimpleExpression<V>> MapPath represents map paths
class	NumberPath<D extends Number & Comparable<?>> NumberPath represents numeric paths
class	PathBuilder<D> PathBuilder is an extension to EntityPathBase for dynamic path construction
class	SetPath<E,Q extends SimpleExpression<E>> SetPath represents set paths
class	SimplePath<D> SimplePath represents simple paths
class	StringPath StringPath represents String typed paths
class	TimePath<D extends Comparable> TimePath represented Time paths

Methods in com.mysema.query.types.path with type parameters of type Path

protected <P extends Path<?>> P

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

<A> SimplePath<A>

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 D> type, Path<?> parent, String property)

BooleanPath(Path<?> parent, String property)

CollectionPath(Class<? super E> type, Class<Q> queryType, Path<?> parent, String property)

ComparablePath(Class<? extends D> type, Path<?> parent, String property)

DatePath(Class<? extends D> type, Path<?> parent, String property)

DateTimePath(Class<? extends D> type, Path<?> parent, String property)

EnumPath(Class<? extends D> 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 D> type, Path<?> parent, String property)

SetPath(Class<? super E> type, Class<Q> queryType, Path<?> parent, String property)

SimplePath(Class<? extends D> type, Path<?> parent, String property)

StringPath(Path<?> parent, String property)

TimePath(Class<? extends D> type, Path<?> parent, String property)