com.mysema.query.support
Class QueryMixin<T>

java.lang.Object
  com.mysema.query.support.QueryMixin<T>

Type Parameters:

T - type of wrapped query

Direct Known Subclasses:

ColQueryMixin, JDOQLQueryMixin, JPQLQueryMixin, SQLQueryMixin

public class QueryMixin<T>
extends Object

Mixin style Query implementation

Author:

tiwe

Constructor Summary

QueryMixin()

QueryMixin(QueryMetadata metadata)

QueryMixin(T self)

QueryMixin(T self, QueryMetadata metadata)

Method Summary

T	addFlag(QueryFlag queryFlag)
T	addToProjection(Expression<?>... o)
Expression<?>[]	convert(Expression<?>[] exprs)
<RT> Expression<RT>	convert(Expression<RT> expr)
protected <D> Expression<D>	createAlias(CollectionExpression<?,D> target, Path<D> alias)
protected <D> Expression<D>	createAlias(Expression<D> path, Path<D> alias)
protected <D> Expression<D>	createAlias(MapExpression<?,D> target, Path<D> alias)
protected <D> Expression<D>	createAlias(SubQueryExpression<D> path, Path<D> alias)
T	distinct()
boolean	equals(Object o)
T	from(EntityPath<?>... args)
T	from(Expression<?>... args)
<P> T	fullJoin(CollectionExpression<?,P> target)
<P> T	fullJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> T	fullJoin(EntityPath<P> target)
<P> T	fullJoin(EntityPath<P> target, EntityPath<P> alias)
<P> T	fullJoin(MapExpression<?,P> target)
<P> T	fullJoin(MapExpression<?,P> target, Path<P> alias)
<P> T	fullJoin(SubQueryExpression<P> target, Path alias)
QueryMetadata	getMetadata()
T	getSelf()
T	groupBy(Expression<?>... o)
int	hashCode()
T	having(Predicate... o)
<P> T	innerJoin(CollectionExpression<?,P> target)
<P> T	innerJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> T	innerJoin(EntityPath<P> target)
<P> T	innerJoin(EntityPath<P> target, EntityPath<P> alias)
<P> T	innerJoin(MapExpression<?,P> target)
<P> T	innerJoin(MapExpression<?,P> target, Path<P> alias)
<P> T	innerJoin(SubQueryExpression<P> target, Path alias)
boolean	isDistinct()
boolean	isUnique()
<P> T	join(CollectionExpression<?,P> target)
<P> T	join(CollectionExpression<?,P> target, Path<P> alias)
<P> T	join(EntityPath<P> target)
<P> T	join(EntityPath<P> target, EntityPath<P> alias)
<P> T	join(MapExpression<?,P> target)
<P> T	join(MapExpression<?,P> target, Path<P> alias)
<P> T	join(SubQueryExpression<P> target, Path alias)
<P> T	leftJoin(CollectionExpression<?,P> target)
<P> T	leftJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> T	leftJoin(EntityPath<P> target)
<P> T	leftJoin(EntityPath<P> target, EntityPath<P> alias)
<P> T	leftJoin(MapExpression<?,P> target)
<P> T	leftJoin(MapExpression<?,P> target, Path<P> alias)
<P> T	leftJoin(SubQueryExpression<P> target, Path alias)
T	limit(long limit)
protected Predicate[]	normalize(Predicate[] conditions, boolean where)
T	offset(long offset)
T	on(Predicate... conditions)
T	orderBy(OrderSpecifier<?>... o)
T	restrict(QueryModifiers modifiers)
<P> T	rightJoin(CollectionExpression<?,P> target)
<P> T	rightJoin(CollectionExpression<?,P> target, Path<P> alias)
<P> T	rightJoin(EntityPath<P> target)
<P> T	rightJoin(EntityPath<P> target, EntityPath<P> alias)
<P> T	rightJoin(MapExpression<?,P> target)
<P> T	rightJoin(MapExpression<?,P> target, Path<P> alias)
<P> T	rightJoin(SubQueryExpression<P> target, Path alias)
<P> T	set(ParamExpression<P> param, P value)
void	setDistinct(boolean distinct)
void	setSelf(T self)
void	setUnique(boolean unique)
String	toString()
T	where(Predicate... o)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

QueryMixin

public QueryMixin()

QueryMixin

public QueryMixin(QueryMetadata metadata)

QueryMixin

public QueryMixin(T self)

QueryMixin

public QueryMixin(T self,
                  QueryMetadata metadata)

Method Detail

addFlag

public T addFlag(QueryFlag queryFlag)

addToProjection

public T addToProjection(Expression<?>... o)

convert

public <RT> Expression<RT> convert(Expression<RT> expr)

convert

public Expression<?>[] convert(Expression<?>[] exprs)

createAlias

protected <D> Expression<D> createAlias(Expression<D> path,
                                        Path<D> alias)

createAlias

protected <D> Expression<D> createAlias(CollectionExpression<?,D> target,
                                        Path<D> alias)

createAlias

protected <D> Expression<D> createAlias(MapExpression<?,D> target,
                                        Path<D> alias)

createAlias

protected <D> Expression<D> createAlias(SubQueryExpression<D> path,
                                        Path<D> alias)

distinct

public T distinct()

from

public T from(Expression<?>... args)

from

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

fullJoin

public <P> T fullJoin(EntityPath<P> target)

fullJoin

public <P> T fullJoin(EntityPath<P> target,
                      EntityPath<P> alias)

fullJoin

public <P> T fullJoin(CollectionExpression<?,P> target)

fullJoin

public <P> T fullJoin(CollectionExpression<?,P> target,
                      Path<P> alias)

fullJoin

public <P> T fullJoin(MapExpression<?,P> target)

fullJoin

public <P> T fullJoin(MapExpression<?,P> target,
                      Path<P> alias)

fullJoin

public <P> T fullJoin(SubQueryExpression<P> target,
                      Path alias)

getMetadata

public QueryMetadata getMetadata()

getSelf

public T getSelf()

groupBy

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

having

public T having(Predicate... o)

innerJoin

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

innerJoin

public <P> T innerJoin(EntityPath<P> target,
                       EntityPath<P> alias)

innerJoin

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

innerJoin

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

innerJoin

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

innerJoin

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

innerJoin

public <P> T innerJoin(SubQueryExpression<P> target,
                       Path alias)

isDistinct

public boolean isDistinct()

isUnique

public boolean isUnique()

join

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

join

public <P> T join(EntityPath<P> target,
                  EntityPath<P> alias)

join

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

join

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

join

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

join

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

join

public <P> T join(SubQueryExpression<P> target,
                  Path alias)

leftJoin

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

leftJoin

public <P> T leftJoin(EntityPath<P> target,
                      EntityPath<P> alias)

leftJoin

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

leftJoin

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

leftJoin

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

leftJoin

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

leftJoin

public <P> T leftJoin(SubQueryExpression<P> target,
                      Path alias)

limit

public T limit(long limit)

offset

public T offset(long offset)

on

public T on(Predicate... conditions)

orderBy

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

restrict

public T restrict(QueryModifiers modifiers)

rightJoin

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

rightJoin

public <P> T rightJoin(EntityPath<P> target,
                       EntityPath<P> alias)

rightJoin

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

rightJoin

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

rightJoin

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

rightJoin

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

rightJoin

public <P> T rightJoin(SubQueryExpression<P> target,
                       Path alias)

set

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

setDistinct

public void setDistinct(boolean distinct)

setSelf

public void setSelf(T self)

setUnique

public void setUnique(boolean unique)

where

public T where(Predicate... o)

normalize

protected Predicate[] normalize(Predicate[] conditions,
                                boolean where)

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toString

public String toString()

Overrides:

toString in class Object