com.mysema.query.types

Class ExpressionUtils

java.lang.Object

com.mysema.query.types.ExpressionUtils

public final class ExpressionUtils
extends Object

ExpressionUtils provides utilities for constructing common operation instances. This class is used internally in Querydsl and is not suitable to be used in cases where DSL methods are needed, since the Expression implementations used in this class are minimal internal implementations.

Author:

tiwe

Method Summary

Modifier and Type	Method and Description
static <T> Expression<T>	all(CollectionExpression<?,? super T> col)
static Predicate	allOf(Collection<Predicate> exprs) Create the intersection of the given arguments
static Predicate	allOf(Predicate... exprs) Create the intersection of the given arguments
static Predicate	and(Predicate left, Predicate right) Create the intersection of the given arguments
static <T> Expression<T>	any(CollectionExpression<?,? super T> col)
static Predicate	anyOf(Collection<Predicate> exprs) Create the union of the given arguments
static Predicate	anyOf(Predicate... exprs) Create the union of the given arguments
static <D> Expression<D>	as(Expression<D> source, Path<D> alias) Create an alias expression (source as alias) with the given source and alias
static <D> Expression<D>	as(Expression<D> source, String alias) Create an alias expression (source as alias) with the given source and alias
static Expression<Long>	count(Expression<?> source)
static String	createRootVariable(Path<?> path) Create a new root variable based on the given path
static String	createRootVariable(Path<?> path, int suffix) Create a new root variable based on the given path and suffix
static com.google.common.collect.ImmutableList<Expression<?>>	distinctList(Expression<?>... args) Get a distinct list of the given args
static com.google.common.collect.ImmutableList<Expression<?>>	distinctList(Expression<?>[]... args) Get a distinct list of the concatenated array contents
static <D> Predicate	eq(Expression<D> left, Expression<? extends D> right) Create an left equals right expression
static <D> Predicate	eqConst(Expression<D> left, D constant) Create an left equals constant expression
static <T> Expression<T>	extract(Expression<T> expr) Get the potentially wrapped expression
static <D> Predicate	in(Expression<D> left, Collection<? extends D> right) Create an left in right expression
static <D> Predicate	in(Expression<D> left, CollectionExpression<?,? extends D> right) Create an left in right expression
static <D> Predicate	inAny(Expression<D> left, Iterable<? extends Collection<? extends D>> lists) Create a left in right or... expression for each list
static Predicate	isNotNull(Expression<?> left) Create a left is not null expression
static Predicate	isNull(Expression<?> left) Create a left is null expression
static Expression<String>	likeToRegex(Expression<String> expr) Convert the given like pattern to a regex pattern
static Expression<String>	likeToRegex(Expression<String> expr, boolean matchStartAndEnd)
static <T> Expression<T>	list(Class<T> clazz, Expression<?>... exprs)
static <T> Expression<T>	list(Class<T> clazz, List<? extends Expression<?>> exprs)
static <D> Predicate	ne(Expression<D> left, Expression<? super D> right) Create a left not equals right expression
static <D> Predicate	neConst(Expression<D> left, D constant) Create a left not equals constant expression
static <D> Predicate	notIn(Expression<D> left, Collection<? extends D> right) Create an left not in right expression
static <D> Predicate	notIn(Expression<D> left, CollectionExpression<?,? extends D> right) Create an left not in right expression
static <D> Predicate	notInAny(Expression<D> left, Iterable<? extends Collection<? extends D>> lists) Create a left not in right and... expression for each list
static <T> Operation<T>	operation(Class<? extends T> type, Operator<T> operator, Expression<?>... args) Create a new Operation expression
static <T> Operation<T>	operation(Class<? extends T> type, Operator<T> operator, com.google.common.collect.ImmutableList<Expression<?>> args) Create a new Operation expression
static Predicate	or(Predicate left, Predicate right) Create a left or right expression
static Expression<?>	orderBy(List<OrderSpecifier<?>> args) Create an expression out of the given order specifiers
static <T> Path<T>	path(Class<? extends T> type, Path<?> parent, String property) Create a new Path expression
static <T> Path<T>	path(Class<? extends T> type, PathMetadata metadata) Create a new Path expression
static <T> Path<T>	path(Class<? extends T> type, String variable) Create a new Path expression
static PredicateOperation	predicate(Operator<Boolean> operator, Expression<?>... args) Create a new Operation expression
static PredicateOperation	predicate(Operator<Boolean> operator, com.google.common.collect.ImmutableList<Expression<?>> args) Create a new Operation expression
static PredicateTemplate	predicateTemplate(String template, com.google.common.collect.ImmutableList<?> args) Create a new Template expression
static PredicateTemplate	predicateTemplate(String template, Object... args) Create a new Template expression
static PredicateTemplate	predicateTemplate(Template template, com.google.common.collect.ImmutableList<?> args) Create a new Template expression
static PredicateTemplate	predicateTemplate(Template template, Object... args) Create a new Template expression
static Expression<String>	regexToLike(Expression<String> expr)
static <T> TemplateExpression<T>	template(Class<? extends T> cl, String template, com.google.common.collect.ImmutableList<?> args) Create a new Template expression
static <T> TemplateExpression<T>	template(Class<? extends T> cl, String template, Object... args) Create a new Template expression
static <T> TemplateExpression<T>	template(Class<? extends T> cl, Template template, com.google.common.collect.ImmutableList<?> args) Create a new Template expression
static <T> TemplateExpression<T>	template(Class<? extends T> cl, Template template, Object... args) Create a new Template expression
static Expression<?>	toExpression(Object o) Converts the given object to an Expression
static Expression<String>	toLower(Expression<String> stringExpression) Converts the given expression to lower(expression)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

operation

public static <T> Operation<T> operation(Class<? extends T> type,
                                         Operator<T> operator,
                                         Expression<?>... args)

Create a new Operation expression

Parameters:

type - type of expression

operator - operator

args - operation arguments

Returns:

operation expression

operation

public static <T> Operation<T> operation(Class<? extends T> type,
                                         Operator<T> operator,
                                         com.google.common.collect.ImmutableList<Expression<?>> args)

Create a new Operation expression

Parameters:

type - type of expression

operator - operator

args - operation arguments

Returns:

operation expression

predicate

public static PredicateOperation predicate(Operator<Boolean> operator,
                                           Expression<?>... args)

Create a new Operation expression

Parameters:

operator - operator

args - operation arguments

Returns:

operation expression

predicate

public static PredicateOperation predicate(Operator<Boolean> operator,
                                           com.google.common.collect.ImmutableList<Expression<?>> args)

Create a new Operation expression

Parameters:

operator - operator

args - operation arguments

Returns:

operation expression

path

public static <T> Path<T> path(Class<? extends T> type,
                               String variable)

Create a new Path expression

Parameters:

type - type of expression

variable - variable name

Returns:

path expression

path

public static <T> Path<T> path(Class<? extends T> type,
                               Path<?> parent,
                               String property)

Create a new Path expression

Parameters:

type - type of expression

parent - parent path

property - property name

Returns:

path expression

path

public static <T> Path<T> path(Class<? extends T> type,
                               PathMetadata metadata)

Create a new Path expression

Type Parameters:

T - type of expression

Parameters:

type - type of expression

metadata - path metadata

Returns:

path expression

predicateTemplate

public static PredicateTemplate predicateTemplate(String template,
                                                  Object... args)

Create a new Template expression

Parameters:

template - template

args - template parameters

Returns:

template expression

predicateTemplate

public static PredicateTemplate predicateTemplate(String template,
                                                  com.google.common.collect.ImmutableList<?> args)

Create a new Template expression

Parameters:

template - template

args - template parameters

Returns:

template expression

predicateTemplate

public static PredicateTemplate predicateTemplate(Template template,
                                                  Object... args)

Create a new Template expression

Parameters:

template - template

args - template parameters

Returns:

template expression

predicateTemplate

public static PredicateTemplate predicateTemplate(Template template,
                                                  com.google.common.collect.ImmutableList<?> args)

Create a new Template expression

Parameters:

template - template

args - template parameters

Returns:

template expression

template

public static <T> TemplateExpression<T> template(Class<? extends T> cl,
                                                 String template,
                                                 Object... args)

Create a new Template expression

Parameters:

cl - type of expression

template - template

args - template parameters

Returns:

template expression

template

public static <T> TemplateExpression<T> template(Class<? extends T> cl,
                                                 String template,
                                                 com.google.common.collect.ImmutableList<?> args)

Create a new Template expression

Parameters:

cl - type of expression

template - template

args - template parameters

Returns:

template expression

template

public static <T> TemplateExpression<T> template(Class<? extends T> cl,
                                                 Template template,
                                                 Object... args)

Create a new Template expression

Parameters:

cl - type of expression

template - template

args - template parameters

Returns:

template expression

template

public static <T> TemplateExpression<T> template(Class<? extends T> cl,
                                                 Template template,
                                                 com.google.common.collect.ImmutableList<?> args)

Create a new Template expression

Parameters:

cl - type of expression

template - template

args - template parameters

Returns:

template expression

all

public static <T> Expression<T> all(CollectionExpression<?,? super T> col)

Parameters:

col -

Returns:

any

public static <T> Expression<T> any(CollectionExpression<?,? super T> col)

Parameters:

col -

Returns:

allOf

@Nullable
public static Predicate allOf(Collection<Predicate> exprs)

Create the intersection of the given arguments

Parameters:

exprs -

Returns:

allOf

@Nullable
public static Predicate allOf(Predicate... exprs)

Create the intersection of the given arguments

Parameters:

exprs -

Returns:

and

public static Predicate and(Predicate left,
                            Predicate right)

Create the intersection of the given arguments

Parameters:

left -

right -

Returns:

anyOf

@Nullable
public static Predicate anyOf(Collection<Predicate> exprs)

Create the union of the given arguments

Parameters:

exprs -

Returns:

anyOf

@Nullable
public static Predicate anyOf(Predicate... exprs)

Create the union of the given arguments

Parameters:

exprs -

Returns:

as

public static <D> Expression<D> as(Expression<D> source,
                                   Path<D> alias)

Create an alias expression (source as alias) with the given source and alias

Type Parameters:

D -

Parameters:

source -

alias -

Returns:

as

public static <D> Expression<D> as(Expression<D> source,
                                   String alias)

Create an alias expression (source as alias) with the given source and alias

Type Parameters:

D -

Parameters:

source -

alias -

Returns:

count

public static Expression<Long> count(Expression<?> source)

Parameters:

source -

Returns:

eqConst

public static <D> Predicate eqConst(Expression<D> left,
                                    D constant)

Create an left equals constant expression

Type Parameters:

D -

Parameters:

left -

constant -

Returns:

eq

public static <D> Predicate eq(Expression<D> left,
                               Expression<? extends D> right)

Create an left equals right expression

Type Parameters:

D -

Parameters:

left -

right -

Returns:

in

public static <D> Predicate in(Expression<D> left,
                               CollectionExpression<?,? extends D> right)

Create an left in right expression

Type Parameters:

D -

Parameters:

left -

right -

Returns:

in

public static <D> Predicate in(Expression<D> left,
                               Collection<? extends D> right)

Create an left in right expression

Type Parameters:

D -

Parameters:

left -

right -

Returns:

inAny

public static <D> Predicate inAny(Expression<D> left,
                                  Iterable<? extends Collection<? extends D>> lists)

Create a left in right or... expression for each list

Type Parameters:

D -

Parameters:

left -

lists -

Returns:

a left in right or... expression

isNull

public static Predicate isNull(Expression<?> left)

Create a left is null expression

Parameters:

left -

Returns:

isNotNull

public static Predicate isNotNull(Expression<?> left)

Create a left is not null expression

Parameters:

left -

Returns:

likeToRegex

public static Expression<String> likeToRegex(Expression<String> expr)

Convert the given like pattern to a regex pattern

Parameters:

expr -

Returns:

likeToRegex

public static Expression<String> likeToRegex(Expression<String> expr,
                                             boolean matchStartAndEnd)

list

public static <T> Expression<T> list(Class<T> clazz,
                                     Expression<?>... exprs)

Parameters:

exprs -

Returns:

list

public static <T> Expression<T> list(Class<T> clazz,
                                     List<? extends Expression<?>> exprs)

Parameters:

exprs -

Returns:

regexToLike

public static Expression<String> regexToLike(Expression<String> expr)

neConst

public static <D> Predicate neConst(Expression<D> left,
                                    D constant)

Create a left not equals constant expression

Type Parameters:

D -

Parameters:

left -

constant -

Returns:

ne

public static <D> Predicate ne(Expression<D> left,
                               Expression<? super D> right)

Create a left not equals right expression

Type Parameters:

D -

Parameters:

left -

right -

Returns:

notIn

public static <D> Predicate notIn(Expression<D> left,
                                  CollectionExpression<?,? extends D> right)

Create an left not in right expression

Type Parameters:

D -

Parameters:

left -

right -

Returns:

notIn

public static <D> Predicate notIn(Expression<D> left,
                                  Collection<? extends D> right)

Create an left not in right expression

Type Parameters:

D -

Parameters:

left -

right -

Returns:

notInAny

public static <D> Predicate notInAny(Expression<D> left,
                                     Iterable<? extends Collection<? extends D>> lists)

Create a left not in right and... expression for each list

Type Parameters:

D -

Parameters:

left -

lists -

Returns:

a left not in right and... expression

or

public static Predicate or(Predicate left,
                           Predicate right)

Create a left or right expression

Parameters:

left -

right -

Returns:

distinctList

public static com.google.common.collect.ImmutableList<Expression<?>> distinctList(Expression<?>... args)

Get a distinct list of the given args

Parameters:

args -

Returns:

distinctList

public static com.google.common.collect.ImmutableList<Expression<?>> distinctList(Expression<?>[]... args)

Get a distinct list of the concatenated array contents

Parameters:

args -

Returns:

extract

public static <T> Expression<T> extract(Expression<T> expr)

Get the potentially wrapped expression

Parameters:

expr -

Returns:

createRootVariable

public static String createRootVariable(Path<?> path)

Create a new root variable based on the given path

Parameters:

path -

Returns:

createRootVariable

public static String createRootVariable(Path<?> path,
                                        int suffix)

Create a new root variable based on the given path and suffix

Parameters:

path - base path

suffix - suffix for variable name

Returns:

path expression

toExpression

public static Expression<?> toExpression(Object o)

Converts the given object to an Expression

Parameters:

o -

Returns:

toLower

public static Expression<String> toLower(Expression<String> stringExpression)

Converts the given expression to lower(expression)

Constants are lower()ed at creation time

Parameters:

stringExpression - the string to lower()

Returns:

lower(stringExpression)

orderBy

public static Expression<?> orderBy(List<OrderSpecifier<?>> args)

Create an expression out of the given order specifiers

Parameters:

args -

Returns: