Package com.querydsl.jpa

Interface JPQLSubQuery<T>

All Superinterfaces:

Expression<T>, java.io.Serializable, SubQueryExpression<T>

public interface JPQLSubQuery<T>
extends SubQueryExpression<T>

Method Summary

Modifier and Type	Method	Description
<R,C> R	accept(Visitor<R,C> v, C context)
JPQLSubQuery<T>	clone()
BooleanExpression	contains(Expression<? extends T> right)
BooleanExpression	contains(T constant)
JPQLSubQuery<T>	distinct()	Set the Query to return distinct results
BooleanExpression	eq(Expression<? extends T> expr)
BooleanExpression	eq(T constant)
BooleanExpression	exists()
JPQLSubQuery<T>	fetchJoin()
<P> JPQLSubQuery<T>	from(CollectionExpression<?,P> target, Path<P> alias)
JPQLSubQuery<T>	from(EntityPath<?> arg)
JPQLSubQuery<T>	from(EntityPath<?>... args)
QueryMetadata	getMetadata()
java.lang.Class<T>	getType()
BooleanExpression	goe(Expression<? extends T> expr)
BooleanExpression	goe(T constant)
JPQLSubQuery<T>	groupBy(Expression<?> e)	Add a single grouping expression
JPQLSubQuery<T>	groupBy(Expression<?>... o)	Add grouping/aggregation expressions
BooleanExpression	gt(Expression<? extends T> expr)
BooleanExpression	gt(T constant)
JPQLSubQuery<T>	having(Predicate e)	Add a single filter for aggregation
JPQLSubQuery<T>	having(Predicate... o)	Add filters for aggregation
BooleanExpression	in(java.util.Collection<? extends T> right)
BooleanExpression	in(T... right)
<P> JPQLSubQuery<T>	innerJoin(CollectionExpression<?,P> target)
<P> JPQLSubQuery<T>	innerJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> JPQLSubQuery<T>	innerJoin(EntityPath<P> target)
<P> JPQLSubQuery<T>	innerJoin(EntityPath<P> target, Path<P> alias)
<P> JPQLSubQuery<T>	innerJoin(MapExpression<?,P> target)
<P> JPQLSubQuery<T>	innerJoin(MapExpression<?,P> target, Path<P> alias)
BooleanOperation	isNotNull()
BooleanOperation	isNull()
<P> JPQLSubQuery<T>	join(CollectionExpression<?,P> target)
<P> JPQLSubQuery<T>	join(CollectionExpression<?,P> target, Path<P> alias)
<P> JPQLSubQuery<T>	join(EntityPath<P> target)
<P> JPQLSubQuery<T>	join(EntityPath<P> target, Path<P> alias)
<P> JPQLSubQuery<T>	join(MapExpression<?,P> target)
<P> JPQLSubQuery<T>	join(MapExpression<?,P> target, Path<P> alias)
<P> JPQLSubQuery<T>	leftJoin(CollectionExpression<?,P> target)
<P> JPQLSubQuery<T>	leftJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> JPQLSubQuery<T>	leftJoin(EntityPath<P> target)
<P> JPQLSubQuery<T>	leftJoin(EntityPath<P> target, Path<P> alias)
<P> JPQLSubQuery<T>	leftJoin(MapExpression<?,P> target)
<P> JPQLSubQuery<T>	leftJoin(MapExpression<?,P> target, Path<P> alias)
JPQLSubQuery<T>	limit(long limit)	Defines the limit / max results for the query results
BooleanExpression	loe(Expression<? extends T> expr)
BooleanExpression	loe(T constant)
BooleanExpression	lt(Expression<? extends T> expr)
BooleanExpression	lt(T constant)
BooleanExpression	ne(Expression<? extends T> expr)
BooleanExpression	ne(T constant)
BooleanExpression	notExists()
JPQLSubQuery<T>	offset(long offset)	Defines the offset for the query results
JPQLSubQuery<T>	on(Predicate condition)
JPQLSubQuery<T>	on(Predicate... conditions)
JPQLSubQuery<T>	orderBy(OrderSpecifier<?> o)	Add a single order expression
JPQLSubQuery<T>	orderBy(OrderSpecifier<?>... o)	Add order expressions
JPQLSubQuery<T>	restrict(QueryModifiers modifiers)	Defines both limit and offset of the query results, use QueryModifiers.EMPTY to apply no paging.
<P> JPQLSubQuery<T>	rightJoin(CollectionExpression<?,P> target)
<P> JPQLSubQuery<T>	rightJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> JPQLSubQuery<T>	rightJoin(EntityPath<P> target)
<P> JPQLSubQuery<T>	rightJoin(EntityPath<P> target, Path<P> alias)
<P> JPQLSubQuery<T>	rightJoin(MapExpression<?,P> target)
<P> JPQLSubQuery<T>	rightJoin(MapExpression<?,P> target, Path<P> alias)
JPQLSubQuery<Tuple>	select(Expression<?>... exprs)
<U> JPQLSubQuery<U>	select(Expression<U> expr)
<P> JPQLSubQuery<T>	set(ParamExpression<P> param, P value)	Set the given parameter to the given value
JPQLSubQuery<T>	where(Predicate o)	Add the given filter condition
JPQLSubQuery<T>	where(Predicate... o)	Add the given filter conditions

Method Detail

clone

JPQLSubQuery<T> clone()

select

<U> JPQLSubQuery<U> select(Expression<U> expr)

select

JPQLSubQuery<Tuple> select(Expression<?>... exprs)

fetchJoin

JPQLSubQuery<T> fetchJoin()

from

JPQLSubQuery<T> from(EntityPath<?> arg)

from

JPQLSubQuery<T> from(EntityPath<?>... args)

from

<P> JPQLSubQuery<T> from(CollectionExpression<?,P> target,
                         Path<P> alias)

innerJoin

<P> JPQLSubQuery<T> innerJoin(CollectionExpression<?,P> target)

innerJoin

<P> JPQLSubQuery<T> innerJoin(CollectionExpression<?,P> target,
                              Path<P> alias)

innerJoin

<P> JPQLSubQuery<T> innerJoin(EntityPath<P> target)

innerJoin

<P> JPQLSubQuery<T> innerJoin(EntityPath<P> target,
                              Path<P> alias)

innerJoin

<P> JPQLSubQuery<T> innerJoin(MapExpression<?,P> target)

innerJoin

<P> JPQLSubQuery<T> innerJoin(MapExpression<?,P> target,
                              Path<P> alias)

join

<P> JPQLSubQuery<T> join(CollectionExpression<?,P> target)

join

<P> JPQLSubQuery<T> join(CollectionExpression<?,P> target,
                         Path<P> alias)

join

<P> JPQLSubQuery<T> join(EntityPath<P> target)

join

<P> JPQLSubQuery<T> join(EntityPath<P> target,
                         Path<P> alias)

join

<P> JPQLSubQuery<T> join(MapExpression<?,P> target)

join

<P> JPQLSubQuery<T> join(MapExpression<?,P> target,
                         Path<P> alias)

leftJoin

<P> JPQLSubQuery<T> leftJoin(CollectionExpression<?,P> target)

leftJoin

<P> JPQLSubQuery<T> leftJoin(CollectionExpression<?,P> target,
                             Path<P> alias)

leftJoin

<P> JPQLSubQuery<T> leftJoin(EntityPath<P> target)

leftJoin

<P> JPQLSubQuery<T> leftJoin(EntityPath<P> target,
                             Path<P> alias)

leftJoin

<P> JPQLSubQuery<T> leftJoin(MapExpression<?,P> target)

leftJoin

<P> JPQLSubQuery<T> leftJoin(MapExpression<?,P> target,
                             Path<P> alias)

rightJoin

<P> JPQLSubQuery<T> rightJoin(CollectionExpression<?,P> target)

rightJoin

<P> JPQLSubQuery<T> rightJoin(CollectionExpression<?,P> target,
                              Path<P> alias)

rightJoin

<P> JPQLSubQuery<T> rightJoin(EntityPath<P> target)

rightJoin

<P> JPQLSubQuery<T> rightJoin(EntityPath<P> target,
                              Path<P> alias)

rightJoin

<P> JPQLSubQuery<T> rightJoin(MapExpression<?,P> target)

rightJoin

<P> JPQLSubQuery<T> rightJoin(MapExpression<?,P> target,
                              Path<P> alias)

on

JPQLSubQuery<T> on(Predicate condition)

on

JPQLSubQuery<T> on(Predicate... conditions)

contains

BooleanExpression contains(Expression<? extends T> right)

contains

BooleanExpression contains(T constant)

exists

BooleanExpression exists()

eq

BooleanExpression eq(Expression<? extends T> expr)

eq

BooleanExpression eq(T constant)

ne

BooleanExpression ne(Expression<? extends T> expr)

ne

BooleanExpression ne(T constant)

notExists

BooleanExpression notExists()

lt

BooleanExpression lt(Expression<? extends T> expr)

lt

BooleanExpression lt(T constant)

gt

BooleanExpression gt(Expression<? extends T> expr)

gt

BooleanExpression gt(T constant)

loe

BooleanExpression loe(Expression<? extends T> expr)

loe

BooleanExpression loe(T constant)

goe

BooleanExpression goe(Expression<? extends T> expr)

goe

BooleanExpression goe(T constant)

isNull

BooleanOperation isNull()

isNotNull

BooleanOperation isNotNull()

getMetadata

QueryMetadata getMetadata()

Specified by:

getMetadata in interface SubQueryExpression<T>

accept

<R,C> R accept(Visitor<R,C> v,
                     C context)

Specified by:

accept in interface Expression<T>

getType

java.lang.Class<T> getType()

Specified by:

getType in interface Expression<T>

in

BooleanExpression in(java.util.Collection<? extends T> right)

in

BooleanExpression in(T... right)

distinct

JPQLSubQuery<T> distinct()

Set the Query to return distinct results

Returns:

the current object

groupBy

JPQLSubQuery<T> groupBy(Expression<?> e)

Add a single grouping expression

Parameters:

e - group by expression

Returns:

the current object

groupBy

JPQLSubQuery<T> groupBy(Expression<?>... o)

Add grouping/aggregation expressions

Parameters:

o - group by expressions

Returns:

the current object

having

JPQLSubQuery<T> having(Predicate e)

Add a single filter for aggregation

Parameters:

e - having condition

Returns:

the current object

having

JPQLSubQuery<T> having(Predicate... o)

Add filters for aggregation

Parameters:

o - having conditions

Returns:

the current object

orderBy

JPQLSubQuery<T> orderBy(OrderSpecifier<?> o)

Add a single order expression

Parameters:

o - order

Returns:

the current object

orderBy

JPQLSubQuery<T> orderBy(OrderSpecifier<?>... o)

Add order expressions

Parameters:

o - order

Returns:

the current object

where

JPQLSubQuery<T> where(Predicate o)

Add the given filter condition

Skips null arguments

Parameters:

o - filter conditions to be added

Returns:

the current object

where

JPQLSubQuery<T> where(Predicate... o)

Add the given filter conditions

Skips null arguments

Parameters:

o - filter conditions to be added

Returns:

the current object

limit

JPQLSubQuery<T> limit(long limit)

Defines the limit / max results for the query results

Parameters:

limit - max rows

Returns:

the current object

offset

JPQLSubQuery<T> offset(long offset)

Defines the offset for the query results

Parameters:

offset - row offset

Returns:

the current object

restrict

JPQLSubQuery<T> restrict(QueryModifiers modifiers)

Defines both limit and offset of the query results, use QueryModifiers.EMPTY to apply no paging.

Parameters:

modifiers - query modifiers

Returns:

the current object

set

<P> JPQLSubQuery<T> set(ParamExpression<P> param,
                        P value)

Set the given parameter to the given value

Type Parameters:

P -

Parameters:

param - param

value - binding

Returns:

the current object