All Classes and Interfaces

Class	Description
AbstractGroupByTransformer<K,T>	Base class for GroupBy result transformers
AbstractGroupExpression<T,R>	A base class for GroupExpressions
Alias	Alias provides alias factory methods
Annotations	Annotations is a merging adapter for the AnnotatedElement interface
ArrayConstructorExpression<T>	ArrayConstructorExpression extends FactoryExpressionBase to represent array initializers
ArrayExpression<A,T>	ArrayExpression defines an interface for array typed expression
ArrayPath<A,E>	ArrayPath represents an array typed path
ArrayUtils	ArrayUtils provides array related utility functionality
BeanMap	An implementation of Map for JavaBeans which uses introspection to get and put properties in the bean.
BeanMap.MyMapEntry	Map entry used by BeanMap.
BeanPath<T>	BeanPath represents bean paths
BeanUtils	BeanUtils provides JavaBean compliant property de/capitalization functionality
BooleanBuilder	BooleanBuilder is a cascading builder for Predicate expressions.
BooleanExpression	BooleanExpression represents Boolean expressions
BooleanOperation	BooleanOperation represents boolean operations
BooleanPath	BooleanPath represents boolean path expressions
BooleanTemplate	BooleanTemplate is a custom boolean expression
CaseBuilder	CaseBuilder enables the construction of typesafe case-when-then-else constructs : e.g.
CaseBuilder.Cases<A,Q extends Expression<A>>	Cascading typesafe Case builder
CaseBuilder.CaseWhen<A,Q extends Expression<A>>	Intermediate When state
CaseBuilder.Initial	Initial state of Case construction
CaseForEqBuilder<D>	CaseForEqBuilder enables the construction of typesafe case-when-then-else constructs for equals-operations : e.g.
Coalesce<T extends Comparable>	Coalesce defines a coalesce function invocation.
CollectionAnyVisitor	CollectionAnyVisitor is an expression visitor which transforms any() path expressions which are often transformed into subqueries
CollectionExpression<T extends Collection<E>,E>	CollectionExpression represents java.util.Collection typed expressions
CollectionExpressionBase<T extends Collection<E>,E>	CollectionExpressionBase is an abstract base class for CollectionExpression implementations
CollectionOperation<E>	CollectionOperation is a collection typed operation
CollectionPath<E,Q extends SimpleExpression<? super E>>	CollectionPath represents collection paths
CollectionPathBase<C extends Collection<E>,E,Q extends SimpleExpression<? super E>>	CollectionPath is a base class for collection typed paths
CollectionUtils	CollectionUtils provides addition operations for Collection types that provide an immutable type for single item collections and after that mutable instances
ComparableEntityPath<T extends Comparable>	ComparableEntityPath extends the ComparablePath class to implement the EntityPath interface
ComparableExpression<T extends Comparable>	ComparableExpression extends ComparableExpressionBase to provide comparison methods.
ComparableExpressionBase<T extends Comparable>	ComparableExpressionBase represents comparable expressions
ComparableOperation<T extends Comparable<?>>	ComparableOperation represents Comparable operations
ComparablePath<T extends Comparable>	ComparablePath represents comparable paths
ComparableTemplate<T extends Comparable<?>>	ComparableTemplate defines custom comparable expressions
Config	Config defines serialization flags for annotated domain types and packages
Constant<T>	Constant represents a general constant expression.
ConstantHidingExpression<T>	ConstantHidingExpression removes constants from the argument list and injects them back into the result chain
ConstantImpl<T>	ConstantImpl is the default implementation of the Constant interface
ConstructorExpression<T>	ConstructorExpression represents a constructor invocation
ConstructorUtils	ConstructorUtils provides constructor resolving functionality
ConstructorUtils.ArgumentTransformer
Context	Context is used in CollectionAnyVisitor as the visitor context
DateExpression<T extends Comparable>	DateExpression represents Date expressions The date representation is compatible with the Gregorian calendar.
DateOperation<T extends Comparable<?>>	DateOperation represents Date operations
DatePath<T extends Comparable>	DatePath presents Date paths
DateTemplate<T extends Comparable<?>>	DateTemplate defines custom date expressions
DateTimeExpression<T extends Comparable>	DateTimeExpression represents Date / Time expressions The date representation is compatible with the Gregorian calendar.
DateTimeOperation<T extends Comparable<?>>	DateTimeOperation represents DateTime operations
DateTimePath<T extends Comparable>	DateTimePath presents DateTime typed paths
DateTimeTemplate<T extends Comparable<?>>	DateTimeTemplate defines custom dateTime expressions
DefaultPathFactory	DefaultPathFactory is the default implementation of the PathFactory interface
DefaultQueryMetadata	DefaultQueryMetadata is the default implementation of the QueryMetadata interface.
DefaultTypeSystem	DefaultTypeSystem is the default implementation of the TypeSystem interface
DeleteClause<C extends DeleteClause<C>>	DeleteClause defines a generic interface for Delete clauses
DMLClause<C extends DMLClause<C>>	Parent interface for DML clauses
DslExpression<T>	DslExpression is the base class for DSL expressions, but SimpleExpression is the base class for scalar Expressions
DslOperation<T>	DslOperation represents a simple operation expression
DslPath<T>	DslPath represents simple paths
DslTemplate<T>	DslTemplate defines custom simple expressions
EmptyMetadata	EmptyMetadata provides an immutable empty QueryMetadata instance.
EntityPath<T>	EntityPath is the common interface for entity path expressions
EntityPathBase<T>	EntityPathBase provides a base class for EntityPath implementations
EnumConversion<T>	EnumConversion ensures that the results of an enum projection conform to the type of the projection expression
EnumExpression<T extends Enum<T>>	EnumExpression represents Enum typed expressions
EnumOperation<T extends Enum<T>>	EnumOperation represents enum operations
EnumPath<T extends Enum<T>>	EnumPath represents enum paths
EnumTemplate<T extends Enum<T>>	EnumTemplate defines custom enum expressions
Expression<T>	Expression defines a general typed expression in a Query instance.
ExpressionBase<T>	ExpressionBase is the base class for immutable Expression implementations
ExpressionException	ExpressionException is thrown for Expression construction issues
Expressions	Factory class for Expression creation.
ExpressionUtils	ExpressionUtils provides utilities for constructing common operation instances.
ExtendedSubQuery<T>	ExtendedSubQuery extends the SubQueryExpression interface to provide fluent expression creation functionality
FactoryExpression<T>	FactoryExpression represents factory expressions such as JavaBean or Constructor projections
FactoryExpressionBase<T>	Common superclass for FactoryExpression implementations
FactoryExpressionUtils	Utility class to expand FactoryExpression constructor arguments and compress FactoryExpression invocation arguments
FactoryExpressionUtils.FactoryExpressionAdapter<T>	FactoryExpressionAdapter provides an adapter implementation of the FactoryExpression interface
Fetchable<T>	Fetchable defines default projection methods for Query implementations.
FetchableQuery<T,Q extends FetchableQuery<T,Q>>	FetchableQuery extends Fetchable and SimpleQuery with projection changing methods and result aggregation functionality using ResultTransformer instances.
FetchableQueryBase<T,Q extends FetchableQueryBase<T,Q>>	FetchableQueryBase extends the QueryBase class to provide default implementations of the methods of the Fetchable interface
FetchableSubQueryBase<T,Q extends FetchableSubQueryBase<T,Q>>	FetchableSubQueryBase extends FetchableQueryBase to provide fluent Expression creation functionality
FileUtils	FileUtils provides File handling functionality
FilteredClause<C extends FilteredClause<C>>	FilteredClause is an interface for clauses with a filter condition
Generated	The Generated annotation is used to mark source code that has been generated.
Group	A group of rows.
GroupBy	GroupBy provides factory methods for ResultTransformer and GroupExpression creation
GroupByBuilder<K>	GroupByBuilder is a fluent builder for GroupBy transformer instances.
GroupByGenericCollection<K,V,RES extends Collection<V>>	Provides aggregated results as a collection
GroupByGenericMap<K,V,RES extends Map<K,V>>	Provides aggregated results as a map
GroupByIterate<K,V>	Provides aggregated results as an iterator
GroupByList<K,V>	Provides aggregated results as a list
GroupByMap<K,V>	Provides aggregated results as a map
GroupByProjection<K,V>	GroupByProjection provides projection of the Group results via the transform template method
GroupCollector<T,R>	A stateful collector of column values for a group.
GroupExpression<T,R>	Defines the way results of a given expression are grouped.
GroupImpl	Default implementation of the Group interface
HashCodeVisitor	HashCodeVisitor is used for hashCode generation in Expression implementations.
Immutable	Immutable marks a class as immutable
InsertClause<C extends InsertClause<C>>	InsertClause defines a generic interface for Insert clauses
JavaSyntaxUtils	Deprecated. use the built-in keyword list instead.
JavaTemplates	JavaTemplates extends Templates to provide Java syntax compliant serialization of Querydsl expressions
JoinExpression	JoinExpression is a join element in a Query instance.
JoinFlag	JoinFlag defines a join related flag using an Expression instance
JoinFlag.Position	The different JoinFlag positions
JoinType	JoinType defines the supported join types
ListExpression<E,Q extends SimpleExpression<? super E>>	ListExpression represents java.util.List typed expressions
ListPath<E,Q extends SimpleExpression<? super E>>	ListPath represents list paths
LiteralExpression<T extends Comparable>	LiteralExpression represents literal expressions
ManagedObject	ManagedObject is a tagging interface for CGLIB alias proxies
MapExpression<K,V>	MapExpression represents java.util.Map typed expressions
MapExpressionBase<K,V,Q extends SimpleExpression<? super V>>	MapExpressionBase is an abstract base class for MapExpression implementations
MapPath<K,V,E extends SimpleExpression<? super V>>	MapPath represents map paths
MappingProjection<T>	Projection template that allows implementing arbitrary mapping of rows to result objects.
MathExpressions	Extended Math expressions, supported by the SQL module
MathUtils	MathUtils provides Math related functionality
MethodType	MethodType defines the supported method types used in the Alias functionality
MixinGroupExpression<E,F,R>	MixinGroupExpression provides nesting support for GroupExpression instances
MultiIterator<T>	MultiIterator provides a cartesian view on the given iterators
MutableExpressionBase<T>	MutableExpressionBase is the base class for mutable Expression implementations
NonUniqueResultException	NonUniqueResultException is thrown for query results where one result row is expected, but multiple are retrieved.
NullExpression<T>	NullExpression defines a general null expression
NullSafeComparableComparator<T extends Comparable<T>>	NullSafeComparableComparator is a null safe comparator for Comparable objects
NumberConversion<T>	NumberConversion ensures that the results of a numeric projection conform to the type of the projection expression
NumberConversions<T>	NumberConversions ensures that the results of a projection involving numeric expressions conform to the types of the numeric expressions
NumberExpression<T extends Number & Comparable<?>>	NumberExpression represents a numeric expression
NumberOperation<T extends Number & Comparable<?>>	NumberOperation represents numeric operations
NumberPath<T extends Number & Comparable<?>>	NumberPath represents numeric paths
NumberTemplate<T extends Number & Comparable<?>>	NumberTemplate defines custom numeric expressions
Operation<T>	Operation represents an operation with operator and arguments
OperationImpl<T>	OperationImpl is the default implementation of the Operation interface
Operator	Operator represents operator symbols.
Ops	Ops provides the operators for the fluent query grammar.
Ops.AggOps	Aggregation operators
Ops.DateTimeOps	Date and time operators
Ops.MathOps	Math operators
Ops.QuantOps	Quantification operators
Ops.StringOps	String operators
Order	Order defines ascending and descending order
OrderedQueryMetadata	OrderedQueryMetadata performs no metadata validation and ensures that FROM elements are before JOIN elements
OrderSpecifier<T extends Comparable>	OrderSpecifier represents an order-by-element in a Query instance
OrderSpecifier.NullHandling	Behaviour for order of null values
Param<T>	Param defines a parameter in a query with an optional name
ParameterizedExpression<T>	ParameterizedExpression is a common interface for expressions with generic type parameters
ParameterizedPathImpl<T>	ParameterizedPathImpl represents Path instances with a parameterized generic type
ParamExpression<T>	ParamExpression defines named and unnamed parameters in queries
ParamExpressionImpl<T>	ParamExpressionImpl defines a parameter in a query with an optional name
ParamNotSetException	ParamNotSetException is thrown when unbound parameters are found before query execution
ParamsVisitor	Copies ParameterExpression bindings from subexpressions to QueryMetadata in the context
Path<T>	Path represents a path expression.
PathBuilder<T>	PathBuilder is an extension to EntityPathBase for dynamic path construction
PathBuilderFactory	PathBuilderFactory is a factory class for PathBuilder creation
PathBuilderValidator	PathBuilderValidator validates PathBuilder properties at creation time
PathExtractor	Extracts the first path that occurs in an expression via breadth first search
PathFactory	PathFactory defines a factory interface for Path creation
PathImpl<T>	PathImpl defines a default implementation of the Path interface
PathInits	PathInits defines path initializations that can be attached to properties via QueryInit annotations
PathMetadata	PathMetadata provides metadata for Path expressions.
PathMetadataFactory	PathMetadataFactory is a factory class for Path construction
PathsExtractor	Extracts the paths that occurs in an expression via breadth first search
PathType	PathType represents the relation of a Path to its parent
Predicate	Predicate is the common interface for Boolean typed expressions
PredicateOperation	PredicateOperation provides a Boolean typed Operation implementation
PredicateTemplate	PredicateTemplate provides a Boolean typed TemplateExpression implementation
PrimitiveUtils	Primitive utility methods.
ProjectionRole<T>	Defines a custom projection for an Expression type.
Projections	Factory class for FactoryExpression instances
PropertyType	PropertyType defines the Path type to be used for a Domain property
QBean<T>	QBean is a JavaBean populating projection type
QList	QList represents a projection of type List
QMap	QMap represents a projection of type Map
QPair<K,V>	A pair of (Map) key and value
QTuple	QTuple represents a projection of type Tuple
Query<Q extends Query<Q>>	Query defines the main query interface of the fluent query language.
QueryBase<Q extends QueryBase<Q>>	QueryBase provides a stub for Query implementations
QueryDelegate	Declaration of a static delegate method
QueryEmbeddable	Annotation for APT based Domain query type generation.
QueryEmbedded	Annotation for APT based Domain query type generation.
QueryEntities	Annotation for APT based Domain query type generation.
QueryEntity	Annotation for APT based Domain query type generation.
QueryException	QueryException is thrown for exceptional query construction issues
QueryExclude	Marks the annotated classes and packages to be excluded from source generation
QueryFactory<Q extends Query<?>>	Common interface for QueryFactory implementations
QueryFlag	Defines a positioned flag in a Query for customization of query serialization
QueryFlag.Position	The different QueryFlag positions
QueryInit	Defines the paths to be initialized for the annotated property
QueryMetadata	QueryMetadata defines query metadata such as query sources, filtering conditions and the projection
QueryMixin<T>	Mixin style Query implementation
QueryMixin.Role	Role of expression in conversion
QueryModifiers	QueryModifiers combines limit and offset info into a single immutable value type.
QueryProjection	Annotation for APT based query type generation.
QueryResults<T>	QueryResults bundles data for paged query results
QuerySupertype	Annotation for APT based Domain query type generation.
QueryTransient	Annotate fields and getters that should be skipped in APT based code generation with this annotation
QueryType	QueryType defines the Querydsl property type for a Domain property
ReflectionUtils	ReflectionUtils provides Reflection related functionality
ReplaceVisitor<C>	ReplaceVisitor is a deep visitor that can be customized to replace segments of expression trees
ResultSetAdapter	ResultSetAdapter is an adapter implementation of the ResultSet interface
ResultTransformer<T>	Executes query on a FetchableQuery and transforms results into T.
SerializerBase<S extends SerializerBase<S>>	SerializerBase is a stub for Serializer implementations which serialize query metadata to Strings
SetPath<E,Q extends SimpleExpression<? super E>>	SetPath represents set paths
SimpleExpression<T>	SimpleExpression is the base class for Expression implementations.
SimpleOperation<T>	SimpleOperation represents a simple operation expression
SimplePath<T>	SimplePath represents simple paths
SimpleQuery<Q extends SimpleQuery<Q>>	SimpleQuery defines a simple querying interface than Query
SimpleTemplate<T>	SimpleTemplate defines custom simple expressions
StoreClause<C extends StoreClause<C>>	Parent interface for InsertClause and UpdateClause
StringExpression	StringExpression represents String expressions
StringExpressions	Extended String expressions, supported by the SQL module
StringOperation	StringOperation represents a String typed operation
StringPath	StringPath represents String typed paths
StringTemplate	StringTemplate defines custom String expressions
StringUtils	String utilities
SubQueryExpression<T>	SubQueryExpression represents a sub query.
SubQueryExpressionImpl<T>	SubQueryExpressionImpl is the default implementation of the SubQueryExpression interface
Template	Template provides serialization templates for Template.Operation, TemplateExpression and Path serialization
Template.AsString	Expression as string
Template.ByIndex	Argument by index
Template.Element	General template element
Template.Operation	Math operation
Template.OperationConst	Math operation with constant
Template.StaticText	Static text element
Template.Transformed	Transformed expression
TemplateExpression<T>	TemplateExpression provides base types for custom expressions with integrated serialization templates
TemplateExpressionImpl<T>	Default implementation of the TemplateExpression interface
TemplateFactory	TemplateFactory is a factory for Template instances
Templates	Templates provides operator patterns for query expression serialization
Templates.Precedence	Precedence order based on Java language operator precedence
TemporalExpression<T extends Comparable>	TemporalExpression is a supertype for Date/Time related types
TimeExpression<T extends Comparable>	TimeExpression represents Time expressions
TimeOperation<T extends Comparable<?>>	TimeOperation represents Time operations
TimePath<T extends Comparable>	TimePath represented Time paths
TimeTemplate<T extends Comparable<?>>	TimeTemplate defines custom time expressions
ToStringVisitor	ToStringVisitor is used for toString() serialization in Expression implementations.
Tuple	Tuple defines an interface for generic query result projection
TypeSystem	TypeSystem defines an interface for detecting whether a given class conforms to a certain Collection contract
UpdateClause<C extends UpdateClause<C>>	UpdateClause defines a generic extensible interface for Update clauses
ValidatingVisitor	ValidatingVisitor visits expressions and ensures that only known path instances are used
Visitor<R,C>	Visitor defines a visitor signature for Expression instances.
Wildcard	Wildcard provides constant Expressions for general wildcard expressions