Package | Description |
---|---|
com.querydsl.collections |
Java Bean collections support
|
com.querydsl.core.dml |
DML interfaces
|
com.querydsl.core.support |
Various support classes
|
com.querydsl.core.types |
Expression types
|
com.querydsl.core.types.dsl |
DSL expression types
|
com.querydsl.jdo |
JDO support
|
com.querydsl.jdo.sql |
SQL queries for JDO
|
com.querydsl.jpa |
JPA support
|
com.querydsl.jpa.hibernate |
JPQL for Hibernate
|
com.querydsl.jpa.hibernate.sql |
Native queries for Hibernate
|
com.querydsl.jpa.impl |
JPQL for JPA
|
com.querydsl.jpa.sql |
Native queries for JPA
|
com.querydsl.mongodb |
MongoDB support
|
com.querydsl.sql |
SQL/JDBC support
|
com.querydsl.sql.dml |
DML operations support
|
com.querydsl.sql.mssql |
SQL Server support
|
com.querydsl.sql.mysql |
MySQL support
|
com.querydsl.sql.oracle |
Oracle support
|
com.querydsl.sql.postgresql |
PostgreSQL support
|
com.querydsl.sql.teradata |
Teradata support
|
Modifier and Type | Method and Description |
---|---|
Void |
CollQuerySerializer.visit(SubQueryExpression<?> expr,
Void context) |
Modifier and Type | Method and Description |
---|---|
C |
InsertClause.select(SubQueryExpression<?> subQuery)
Define the populate via subquery
|
Modifier and Type | Interface and Description |
---|---|
interface |
ExtendedSubQuery<T>
ExtendedSubQuery extends the SubQueryExpression interface to provide fluent
expression creation functionality |
Modifier and Type | Class and Description |
---|---|
class |
FetchableSubQueryBase<T,Q extends FetchableSubQueryBase<T,Q>>
FetchableSubQueryBase extends FetchableQueryBase to provide fluent Expression creation functionality |
Modifier and Type | Method and Description |
---|---|
<P> T |
QueryMixin.fullJoin(SubQueryExpression<P> target,
Path<?> alias) |
<P> T |
QueryMixin.innerJoin(SubQueryExpression<P> target,
Path<?> alias) |
<P> T |
QueryMixin.join(SubQueryExpression<P> target,
Path<?> alias) |
<P> T |
QueryMixin.leftJoin(SubQueryExpression<P> target,
Path<?> alias) |
<P> T |
QueryMixin.rightJoin(SubQueryExpression<P> target,
Path<?> alias) |
Expression<?> |
ReplaceVisitor.visit(SubQueryExpression<?> expr,
C context) |
Expression<?> |
CollectionAnyVisitor.visit(SubQueryExpression<?> expr,
Context context) |
Void |
PathsExtractor.visit(SubQueryExpression<?> expr,
List<Path<?>> paths) |
Modifier and Type | Class and Description |
---|---|
class |
SubQueryExpressionImpl<T>
SubQueryExpressionImpl is the default implementation of the SubQueryExpression interface |
Modifier and Type | Method and Description |
---|---|
static <T> Expression<T> |
ExpressionUtils.all(SubQueryExpression<? extends T> col)
Create a
all col expression |
static <T> Expression<T> |
ExpressionUtils.any(SubQueryExpression<? extends T> col)
Create a
any col expression |
static <D> Predicate |
ExpressionUtils.in(Expression<D> left,
SubQueryExpression<? extends D> right)
Create a
left in right expression |
static <D> Predicate |
ExpressionUtils.notIn(Expression<D> left,
SubQueryExpression<? extends D> right)
Create a
left not in right expression |
R |
Visitor.visit(SubQueryExpression<?> expr,
C context)
Visit a SubQueryExpression instance with the given context
|
Void |
ParamsVisitor.visit(SubQueryExpression<?> expr,
QueryMetadata context) |
Set<Expression<?>> |
ValidatingVisitor.visit(SubQueryExpression<?> expr,
Set<Expression<?>> known) |
String |
ToStringVisitor.visit(SubQueryExpression<?> expr,
Templates templates) |
Path<?> |
PathExtractor.visit(SubQueryExpression<?> expr,
Void context) |
Integer |
HashCodeVisitor.visit(SubQueryExpression<?> expr,
Void context) |
Modifier and Type | Method and Description |
---|---|
BooleanExpression |
SimpleExpression.eqAll(SubQueryExpression<? extends T> right)
Create a
this == all right expression |
BooleanExpression |
SimpleExpression.eqAny(SubQueryExpression<? extends T> right)
Create a
this == any right expression |
BooleanExpression |
ComparableExpression.goeAll(SubQueryExpression<? extends T> right)
Create a
this >= all right expression |
BooleanExpression |
ComparableExpression.goeAny(SubQueryExpression<? extends T> right)
Create a
this >= any right expression |
BooleanExpression |
NumberExpression.gtAll(SubQueryExpression<? extends T> right)
Create a
this > all right expression |
BooleanExpression |
ComparableExpression.gtAll(SubQueryExpression<? extends T> right)
Create a
this > all right expression |
BooleanExpression |
NumberExpression.gtAny(SubQueryExpression<? extends T> right)
Create a
this > any right expression |
BooleanExpression |
ComparableExpression.gtAny(SubQueryExpression<? extends T> right)
Create a
this > any right expression |
BooleanExpression |
SimpleExpression.in(SubQueryExpression<? extends T> right)
Create a
this in right expression |
BooleanExpression |
ComparableExpression.loeAll(SubQueryExpression<? extends T> right)
Create a
this <= all right expression |
BooleanExpression |
ComparableExpression.loeAny(SubQueryExpression<? extends T> right)
Create a
this <= any right expression |
BooleanExpression |
ComparableExpression.ltAll(SubQueryExpression<? extends T> right)
Create a
this < all right expression |
BooleanExpression |
ComparableExpression.ltAny(SubQueryExpression<? extends T> right)
Create a
this < any right expression |
BooleanExpression |
SimpleExpression.notIn(SubQueryExpression<? extends T> right)
Create a
this not in right expression |
Modifier and Type | Interface and Description |
---|---|
interface |
JDOQLQuery<T>
Query interface for JDOQL queries
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractJDOQuery<T,Q extends AbstractJDOQuery<T,Q>>
Abstract base class for custom implementations of the
JDOQLQuery interface. |
class |
JDOQuery<T>
JDOQuery is the default implementation of the JDOQLQuery interface |
Modifier and Type | Method and Description |
---|---|
Void |
JDOQLSerializer.visit(SubQueryExpression<?> query,
Void context) |
Modifier and Type | Class and Description |
---|---|
class |
JDOSQLQuery<T>
JDOSQLQuery is a SQLQuery implementation that uses JDO's SQL query functionality
to execute queries |
Modifier and Type | Interface and Description |
---|---|
interface |
JPQLQuery<T>
Query interface for JPQL queries
|
Modifier and Type | Class and Description |
---|---|
class |
JPAQueryBase<T,Q extends JPAQueryBase<T,Q>>
JPAQueryBase is a base Query class for JPA queries |
Modifier and Type | Method and Description |
---|---|
Void |
JPQLSerializer.visit(SubQueryExpression<?> query,
Void context) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractHibernateQuery<T,Q extends AbstractHibernateQuery<T,Q>>
Abstract base class for Hibernate API based implementations of the JPQL interface
|
class |
HibernateQuery<T>
HibernateQuery is the default implementation of the JPQLQuery interface for Hibernate |
Modifier and Type | Class and Description |
---|---|
class |
AbstractHibernateSQLQuery<T,Q extends AbstractHibernateSQLQuery<T,Q>>
AbstractHibernateSQLQuery is the base class for Hibernate Native SQL queries |
class |
HibernateSQLQuery<T>
HibernateSQLQuery is an SQLQuery implementation that uses Hibernate's Native SQL functionality
to execute queries |
Modifier and Type | Class and Description |
---|---|
class |
AbstractJPAQuery<T,Q extends AbstractJPAQuery<T,Q>>
Abstract base class for JPA API based implementations of the JPQLQuery interface
|
class |
JPAQuery<T>
JPAQuery is the default implementation of the JPQLQuery interface for JPA |
Modifier and Type | Class and Description |
---|---|
class |
AbstractJPASQLQuery<T,Q extends AbstractJPASQLQuery<T,Q>>
AbstractJPASQLQuery is the base class for JPA Native SQL queries |
class |
JPASQLQuery<T>
JPASQLQuery is an SQLQuery implementation that uses JPA Native SQL functionality
to execute queries |
Modifier and Type | Method and Description |
---|---|
Object |
MongodbSerializer.visit(SubQueryExpression<?> expr,
Void context) |
Modifier and Type | Interface and Description |
---|---|
interface |
Union<RT>
Union defines an interface for Union queries |
Modifier and Type | Class and Description |
---|---|
class |
AbstractSQLQuery<T,Q extends AbstractSQLQuery<T,Q>>
AbstractSQLQuery is the base type for SQL query implementations |
class |
ProjectableSQLQuery<T,Q extends ProjectableSQLQuery<T,Q> & Query<Q>>
ProjectableSQLQuery is the base type for SQL query implementations |
class |
SQLQuery<T>
SQLQuery is a JDBC based implementation of the SQLCommonQuery
interface |
class |
UnionImpl<T,Q extends ProjectableSQLQuery<T,Q> & Query<Q>>
Default implementation of the Union interface
|
Modifier and Type | Field and Description |
---|---|
protected SubQueryExpression<?> |
ProjectableSQLQuery.firstUnionSubQuery |
Modifier and Type | Method and Description |
---|---|
Q |
SQLCommonQueryFactory.from(SubQueryExpression<?> subQuery,
Path<?> alias)
Create a new SELECT query
|
Q |
SQLCommonQuery.from(SubQueryExpression<?> subQuery,
Path<?> alias)
Adds a sub query source
|
Q |
ProjectableSQLQuery.from(SubQueryExpression<?> subQuery,
Path<?> alias) |
Q |
AbstractSQLQueryFactory.from(SubQueryExpression<?> subQuery,
Path<?> alias) |
Q |
SQLCommonQuery.fullJoin(SubQueryExpression<?> o,
Path<?> alias)
Adds a full join to the given target
|
Q |
ProjectableSQLQuery.fullJoin(SubQueryExpression<?> target,
Path<?> alias) |
BooleanExpression |
ForeignKey.in(SubQueryExpression<Tuple> coll) |
Q |
SQLCommonQuery.innerJoin(SubQueryExpression<?> o,
Path<?> alias)
Adds an inner join to the given target
|
Q |
ProjectableSQLQuery.innerJoin(SubQueryExpression<?> target,
Path<?> alias) |
Q |
SQLCommonQuery.join(SubQueryExpression<?> o,
Path<?> alias)
Adds a join to the given target
|
Q |
ProjectableSQLQuery.join(SubQueryExpression<?> target,
Path<?> alias) |
Q |
SQLCommonQuery.leftJoin(SubQueryExpression<?> o,
Path<?> alias)
Adds a left join to the given target
|
Q |
ProjectableSQLQuery.leftJoin(SubQueryExpression<?> target,
Path<?> alias) |
void |
SQLListeners.notifyInsert(RelationalPath<?> entity,
QueryMetadata md,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLListener.notifyInsert(RelationalPath<?> entity,
QueryMetadata md,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery)
Notify about an insertion
|
void |
SQLBaseListener.notifyInsert(RelationalPath<?> entity,
QueryMetadata md,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLListeners.notifyMerge(RelationalPath<?> entity,
QueryMetadata md,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLListener.notifyMerge(RelationalPath<?> entity,
QueryMetadata md,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery)
Notify about a merge
|
void |
SQLBaseListener.notifyMerge(RelationalPath<?> entity,
QueryMetadata md,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
Q |
SQLCommonQuery.rightJoin(SubQueryExpression<?> o,
Path<?> alias)
Adds a right join to the given target
|
Q |
ProjectableSQLQuery.rightJoin(SubQueryExpression<?> target,
Path<?> alias) |
void |
SQLSerializer.serializeInsert(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLTemplates.serializeInsert(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery,
SQLSerializer context)
template method for INSERT serialization
|
void |
SQLSerializer.serializeMerge(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery) |
void |
SQLTemplates.serializeMerge(QueryMetadata metadata,
RelationalPath<?> entity,
List<Path<?>> keys,
List<Path<?>> columns,
List<Expression<?>> values,
SubQueryExpression<?> subQuery,
SQLSerializer context)
template method for MERGE serialization
|
<RT> Q |
ProjectableSQLQuery.union(Path<?> alias,
SubQueryExpression<RT>... sq)
Creates an union expression for the given subqueries
|
<RT> Union<RT> |
ProjectableSQLQuery.union(SubQueryExpression<RT>... sq)
Creates an union expression for the given subqueries
|
static <T> Union<T> |
SQLExpressions.union(SubQueryExpression<T>... sq)
Create a new UNION clause
|
<RT> Q |
ProjectableSQLQuery.unionAll(Path<?> alias,
SubQueryExpression<RT>... sq)
Creates an union expression for the given subqueries
|
<RT> Union<RT> |
ProjectableSQLQuery.unionAll(SubQueryExpression<RT>... sq)
Creates an union expression for the given subqueries
|
static <T> Union<T> |
SQLExpressions.unionAll(SubQueryExpression<T>... sq)
Create a new UNION ALL clause
|
Set<RelationalPath<?>> |
RelationalPathExtractor.visit(SubQueryExpression<?> expr,
Set<RelationalPath<?>> known) |
Void |
SQLSerializer.visit(SubQueryExpression<?> query,
Void context) |
Q |
SQLCommonQuery.with(Path<?> alias,
SubQueryExpression<?> o)
Adds a common table expression
|
Q |
ProjectableSQLQuery.with(Path<?> alias,
SubQueryExpression<?> query) |
Q |
SQLCommonQuery.withRecursive(Path<?> alias,
SubQueryExpression<?> o)
Adds a common table expression
|
Q |
ProjectableSQLQuery.withRecursive(Path<?> alias,
SubQueryExpression<?> query) |
Modifier and Type | Method and Description |
---|---|
<RT> Union<RT> |
ProjectableSQLQuery.union(List<SubQueryExpression<RT>> sq)
Creates an union expression for the given subqueries
|
static <T> Union<T> |
SQLExpressions.union(List<SubQueryExpression<T>> sq)
Create a new UNION clause
|
<RT> Union<RT> |
ProjectableSQLQuery.unionAll(List<SubQueryExpression<RT>> sq)
Creates an union expression for the given subqueries
|
static <T> Union<T> |
SQLExpressions.unionAll(List<SubQueryExpression<T>> sq)
Create a new UNION ALL clause
|
Modifier and Type | Method and Description |
---|---|
SubQueryExpression<?> |
SQLMergeBatch.getSubQuery() |
SubQueryExpression<?> |
SQLInsertBatch.getSubQuery() |
Modifier and Type | Method and Description |
---|---|
SQLMergeClause |
SQLMergeClause.select(SubQueryExpression<?> subQuery) |
SQLInsertClause |
SQLInsertClause.select(SubQueryExpression<?> sq) |
Constructor and Description |
---|
SQLInsertBatch(List<Path<?>> c,
List<Expression<?>> v,
SubQueryExpression<?> sq) |
SQLMergeBatch(List<Path<?>> k,
List<Path<?>> c,
List<Expression<?>> v,
SubQueryExpression<?> sq) |
Modifier and Type | Class and Description |
---|---|
class |
SQLServerQuery<T>
SQLServerQuery provides SQL Server related extensions to SQLQuery |
Modifier and Type | Class and Description |
---|---|
class |
MySQLQuery<T>
MySQLQuery provides MySQL related extensions to SQLQuery |
Modifier and Type | Class and Description |
---|---|
class |
OracleQuery<T>
OracleQuery provides Oracle specific extensions to the base SQL query type |
Modifier and Type | Class and Description |
---|---|
class |
PostgreSQLQuery<T>
PostgreSQLQuery provides PostgreSQL related extensions to SQLQuery |
Modifier and Type | Class and Description |
---|---|
class |
TeradataQuery<T>
TeradataQuery provides Teradata related extensions to SQLQuery |
Copyright © 2007–2016 Querydsl. All rights reserved.