Package com.querydsl.core.types.dsl

Class NumberExpression<T extends Number & Comparable<?>>

java.lang.Object

com.querydsl.core.types.dsl.DslExpression<T>

com.querydsl.core.types.dsl.SimpleExpression<T>

com.querydsl.core.types.dsl.ComparableExpressionBase<T>

com.querydsl.core.types.dsl.NumberExpression<T>

Type Parameters:

T - expression type

All Implemented Interfaces:

Expression<T>, Serializable

Direct Known Subclasses:

NumberOperation, NumberPath, NumberTemplate

public abstract class NumberExpression<T extends Number & Comparable<?>>
extends ComparableExpressionBase<T>

NumberExpression represents a numeric expression

Author:

tiwe

See Also:

• Number
• Serialized Form

Field Summary

Fields inherited from class com.querydsl.core.types.dsl.DslExpression

hashCode, mixin

Constructor Summary

Constructors

Constructor	Description
NumberExpression(Expression<T> mixin)

Method Summary

Modifier and Type	Method	Description
NumberExpression<T>	abs()	Create a abs(this) expression
<N extends Number & Comparable<?>> NumberExpression<T>	add(Expression<N> right)	Create a this + right expression
<N extends Number & Comparable<N>> NumberExpression<T>	add(N right)	Create a this + right expression
NumberExpression<T>	as(Path<T> alias)	Create an alias for the expression
NumberExpression<T>	as(String alias)	Create an alias for the expression
NumberExpression<Double>	avg()	Create a avg(this) expression
final <A extends Number & Comparable<?>> BooleanExpression	between(@Nullable Expression<A> from, @Nullable Expression<A> to)	Create a this between from and to expression
final <A extends Number & Comparable<?>> BooleanExpression	between(A from, A to)	Create a this between from and to expression
NumberExpression<Byte>	byteValue()	Create a cast(this as byte) expression
<A extends Number & Comparable<? super A>> NumberExpression<A>	castToNum(Class<A> type)
NumberExpression<T>	ceil()	Create a ceil(this) expression
NumberExpression<T>	coalesce(Expression<?>... exprs)	Create a coalesce(this, exprs...) expression
NumberExpression<T>	coalesce(Expression<T> expr)	Create a coalesce(this, expr) expression
NumberExpression<T>	coalesce(T arg)	Create a coalesce(this, arg) expression
NumberExpression<T>	coalesce(T... args)	Create a coalesce(this, args...) expression
<N extends Number & Comparable<?>> NumberExpression<T>	divide(Expression<N> right)	Create a this / right expression
<N extends Number & Comparable<?>> NumberExpression<T>	divide(N right)	Create a this / right expression
NumberExpression<Double>	doubleValue()	Create a cast(this as double) expression
NumberExpression<Float>	floatValue()	Create a cast(this as double) expression
NumberExpression<T>	floor()	Create a floor(this) expression
final <A extends Number & Comparable<?>> BooleanExpression	goe(A right)	Create a this >= right expression
final <A extends Number & Comparable<?>> BooleanExpression	goe(Expression<A> right)	Create a this >= right expression
BooleanExpression	goeAll(CollectionExpression<?,? super T> right)	Create a this >= all right expression
BooleanExpression	goeAny(CollectionExpression<?,? super T> right)	Create a this >= any right expression
final <A extends Number & Comparable<?>> BooleanExpression	gt(A right)	Create a this > right expression
final <A extends Number & Comparable<?>> BooleanExpression	gt(Expression<A> right)	Create a this > right expression
BooleanExpression	gtAll(CollectionExpression<?,? super T> right)	Create a this > all right expression
BooleanExpression	gtAll(SubQueryExpression<? extends T> right)	Create a this > all right expression
BooleanExpression	gtAny(CollectionExpression<?,? super T> right)	Create a this > any right expression
BooleanExpression	gtAny(SubQueryExpression<? extends T> right)	Create a this > any right expression
BooleanExpression	in(Number... numbers)	Create a this in right expression
NumberExpression<Integer>	intValue()	Create a this.intValue() expression
BooleanExpression	like(Expression<String> str)	Create a this like str expression
BooleanExpression	like(String str)	Create a this like str expression
final <A extends Number & Comparable<?>> BooleanExpression	loe(A right)	Create a this <= right expression
final <A extends Number & Comparable<?>> BooleanExpression	loe(Expression<A> right)	Create a this <= right expression
BooleanExpression	loeAll(CollectionExpression<?,? super T> right)	Create a this <= all right expression
BooleanExpression	loeAny(CollectionExpression<?,? super T> right)	Create a this <= any right expression
NumberExpression<Long>	longValue()	Create a this.longValue() expression
final <A extends Number & Comparable<?>> BooleanExpression	lt(A right)	Create a this < right expression
final <A extends Number & Comparable<?>> BooleanExpression	lt(Expression<A> right)	Create a this < right expression
BooleanExpression	ltAll(CollectionExpression<?,? super T> right)	Create a this < all right expression
BooleanExpression	ltAny(CollectionExpression<?,? super T> right)	Create a this < any right expression
NumberExpression<T>	max()	Create a max(this) expression
static <A extends Number & Comparable<?>> NumberExpression<A>	max(Expression<A> left, Expression<A> right)	Create a max(left, right) expression
NumberExpression<T>	min()	Create a min(this) expression
static <A extends Number & Comparable<?>> NumberExpression<A>	min(Expression<A> left, Expression<A> right)	Create a min(left, right) expression
NumberExpression<T>	mod(Expression<T> num)	Create a mod(this, num) expression
NumberExpression<T>	mod(T num)	Create a mod(this, num) expression
<N extends Number & Comparable<?>> NumberExpression<T>	multiply(Expression<N> right)	Create a this * right expression
<N extends Number & Comparable<N>> NumberExpression<T>	multiply(N right)	Create a this * right expression
NumberExpression<T>	negate()	Create a this * -1 expression
final <A extends Number & Comparable<?>> BooleanExpression	notBetween(A from, A to)	Create a this not between from and to expression
final <A extends Number & Comparable<?>> BooleanExpression	notBetween(Expression<A> from, Expression<A> to)	Create a this not between from and to expression
BooleanExpression	notIn(Number... numbers)	Create a this not in right expression
NumberExpression<T>	nullif(Expression<T> other)	Create a nullif(this, other) expression
NumberExpression<T>	nullif(T other)	Create a nullif(this, other) expression
static NumberExpression<Double>	random()	Create a random() expression
NumberExpression<T>	round()	Create a round(this) expression
NumberExpression<Short>	shortValue()	Create a this.shortValue() expression
NumberExpression<Double>	sqrt()	Create a sqrt(this) expression
StringExpression	stringValue()	Create a cast to String expression
<N extends Number & Comparable<?>> NumberExpression<T>	subtract(Expression<N> right)	Create a this - right expression
<N extends Number & Comparable<?>> NumberExpression<T>	subtract(N right)	Create a this - right expression
NumberExpression<T>	sum()	Create a sum(this) expression

Methods inherited from class com.querydsl.core.types.dsl.ComparableExpressionBase

asc, desc

Methods inherited from class com.querydsl.core.types.dsl.SimpleExpression

count, countDistinct, eq, eq, eqAll, eqAll, eqAny, eqAny, in, in, in, in, isNotNull, isNull, ne, ne, neAll, neAny, notIn, notIn, notIn, notIn, when, when

Methods inherited from class com.querydsl.core.types.dsl.DslExpression

equals, getType, hashCode, toString

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.querydsl.core.types.Expression

accept

Constructor Details

NumberExpression

public NumberExpression(Expression<T> mixin)

Method Details

max

public static <A extends Number & Comparable<?>>
NumberExpression<A> max(Expression<A> left,
 Expression<A> right)

Create a max(left, right) expression

Return the greater of the given values

Returns:

max(left, right)

min

public static <A extends Number & Comparable<?>>
NumberExpression<A> min(Expression<A> left,
 Expression<A> right)

Create a min(left, right) expression

Returns the smaller of the given values

Returns:

min(left, right)

random

public static NumberExpression<Double> random()

Create a random() expression

Returns the random number

Returns:

random()

as

public NumberExpression<T> as(Path<T> alias)

Description copied from class: SimpleExpression

Create an alias for the expression

Overrides:

as in class SimpleExpression<T extends Number & Comparable<?>>

Returns:

alias expression

as

public NumberExpression<T> as(String alias)

Description copied from class: SimpleExpression

Create an alias for the expression

Overrides:

as in class SimpleExpression<T extends Number & Comparable<?>>

Returns:

alias expression

stringValue

public StringExpression stringValue()

Create a cast to String expression

Returns:

string representation

See Also:

• Object.toString()

abs

public NumberExpression<T> abs()

Create a abs(this) expression

Returns the absolute value of this expression

Returns:

abs(this)

add

public <N extends Number & Comparable<?>>
NumberExpression<T> add(Expression<N> right)

Create a this + right expression

Returns the sum of this and right

Parameters:

right - rhs of expression

Returns:

this + right

add

public <N extends Number & Comparable<N>>
NumberExpression<T> add(N right)

Create a this + right expression

Get the sum of this and right

Parameters:

right - rhs of expression

Returns:

this + right

avg

public NumberExpression<Double> avg()

Create a avg(this) expression

Get the average value of this expression (aggregation)

Returns:

avg(this)

byteValue

public NumberExpression<Byte> byteValue()

Create a cast(this as byte) expression

Get the byte expression of this numeric expression

Returns:

this.byteValue()

See Also:

• Number.byteValue()

castToNum

public <A extends Number & Comparable<? super A>>
NumberExpression<A> castToNum(Class<A> type)

ceil

public NumberExpression<T> ceil()

Create a ceil(this) expression

Returns the smallest (closest to negative infinity) double value that is greater than or equal to the argument and is equal to a mathematical integer

Returns:

ceil(this)

See Also:

• Math.ceil(double)

divide

public <N extends Number & Comparable<?>>
NumberExpression<T> divide(Expression<N> right)

Create a this / right expression

Get the result of the operation this / right

Parameters:

right -

Returns:

this / right

divide

public <N extends Number & Comparable<?>>
NumberExpression<T> divide(N right)

Create a this / right expression

Get the result of the operation this / right

Parameters:

right -

Returns:

this / right

doubleValue

public NumberExpression<Double> doubleValue()

Create a cast(this as double) expression

Get the double expression of this numeric expression

Returns:

this.doubleValue()

See Also:

• Number.doubleValue()

floatValue

public NumberExpression<Float> floatValue()

Create a cast(this as double) expression

Get the float expression of this numeric expression

Returns:

this.floatValue()

See Also:

• Number.floatValue()

floor

public NumberExpression<T> floor()

Create a floor(this) expression

Returns the largest (closest to positive infinity) double value that is less than or equal to the argument and is equal to a mathematical integer.

Returns:

floor(this)

See Also:

• Math.floor(double)

goe

public final <A extends Number & Comparable<?>>
BooleanExpression goe(A right)

Create a this >= right expression

Type Parameters:

A -

Parameters:

right - rhs of the comparison

Returns:

this >= right

See Also:

• Comparable.compareTo(Object)

goe

public final <A extends Number & Comparable<?>>
BooleanExpression goe(Expression<A> right)

Create a this >= right expression

Type Parameters:

A -

Parameters:

right - rhs of the comparison

Returns:

this >= right

See Also:

• Comparable.compareTo(Object)

goeAll

public BooleanExpression goeAll(CollectionExpression<?,? super T> right)

Create a this >= all right expression

Parameters:

right -

Returns:

this >= all right

goeAny

public BooleanExpression goeAny(CollectionExpression<?,? super T> right)

Create a this >= any right expression

Parameters:

right -

Returns:

this >= any right

gt

public final <A extends Number & Comparable<?>>
BooleanExpression gt(A right)

Create a this > right expression

Type Parameters:

A -

Parameters:

right - rhs of the comparison

Returns:

this > right

See Also:

• Comparable.compareTo(Object)

gt

public final <A extends Number & Comparable<?>>
BooleanExpression gt(Expression<A> right)

Create a this > right expression

Type Parameters:

A -

Parameters:

right - rhs of the comparison

Returns:

this > right

See Also:

• Comparable.compareTo(Object)

gtAll

public BooleanExpression gtAll(CollectionExpression<?,? super T> right)

Create a this > all right expression

Parameters:

right -

Returns:

this > all right

gtAny

public BooleanExpression gtAny(CollectionExpression<?,? super T> right)

Create a this > any right expression

Parameters:

right -

Returns:

this > any right

gtAll

public BooleanExpression gtAll(SubQueryExpression<? extends T> right)

Create a this > all right expression

Parameters:

right -

Returns:

this > all right

gtAny

public BooleanExpression gtAny(SubQueryExpression<? extends T> right)

Create a this > any right expression

Parameters:

right -

Returns:

this > any right

between

public final <A extends Number & Comparable<?>>
BooleanExpression between(@Nullable
 A from,
 @Nullable
 A to)

Create a this between from and to expression

Is equivalent to from <= this <= to

Type Parameters:

A -

Parameters:

from - inclusive start of range

to - inclusive end of range

Returns:

this between from and to

between

public final <A extends Number & Comparable<?>>
BooleanExpression between(@Nullable
 @Nullable Expression<A> from,
 @Nullable
 @Nullable Expression<A> to)

Create a this between from and to expression

Is equivalent to from <= this <= to

Type Parameters:

A -

Parameters:

from - inclusive start of range

to - inclusive end of range

Returns:

this between from and to

notBetween

public final <A extends Number & Comparable<?>>
BooleanExpression notBetween(A from,
 A to)

Create a this not between from and to expression

Is equivalent to this < from || this > to

Parameters:

from - inclusive start of range

to - inclusive end of range

Returns:

this not between from and to

notBetween

public final <A extends Number & Comparable<?>>
BooleanExpression notBetween(Expression<A> from,
 Expression<A> to)

Create a this not between from and to expression

Is equivalent to this < from || this > to

Parameters:

from - inclusive start of range

to - inclusive end of range

Returns:

this not between from and to

intValue

public NumberExpression<Integer> intValue()

Create a this.intValue() expression

Get the int expression of this numeric expression

Returns:

this.intValue()

See Also:

• Number.intValue()

like

public BooleanExpression like(String str)

Create a this like str expression

Parameters:

str - rhs

Returns:

this like str

like

public BooleanExpression like(Expression<String> str)

Create a this like str expression

Parameters:

str -

Returns:

this like str

loe

public final <A extends Number & Comparable<?>>
BooleanExpression loe(A right)

Create a this <= right expression

Type Parameters:

A -

Parameters:

right - rhs of the comparison

Returns:

this <= right

See Also:

• Comparable.compareTo(Object)

loe

public final <A extends Number & Comparable<?>>
BooleanExpression loe(Expression<A> right)

Create a this <= right expression

Type Parameters:

A -

Parameters:

right - rhs of the comparison

Returns:

this <= right

See Also:

• Comparable.compareTo(Object)

loeAll

public BooleanExpression loeAll(CollectionExpression<?,? super T> right)

Create a this <= all right expression

Parameters:

right - rhs

Returns:

this <= all right

loeAny

public BooleanExpression loeAny(CollectionExpression<?,? super T> right)

Create a this <= any right expression

Parameters:

right - rhs

Returns:

this <= any right

longValue

public NumberExpression<Long> longValue()

Create a this.longValue() expression

Get the long expression of this numeric expression

Returns:

this.longValue()

See Also:

• Number.longValue()

lt

public final <A extends Number & Comparable<?>>
BooleanExpression lt(A right)

Create a this < right expression

Type Parameters:

A -

Parameters:

right - rhs of the comparison

Returns:

this < right

See Also:

• Comparable.compareTo(Object)

lt

public final <A extends Number & Comparable<?>>
BooleanExpression lt(Expression<A> right)

Create a this < right expression

Type Parameters:

A -

Parameters:

right - rhs of the comparison

Returns:

this < right

See Also:

• Comparable.compareTo(Object)

ltAll

public BooleanExpression ltAll(CollectionExpression<?,? super T> right)

Create a this < all right expression

Parameters:

right - rhs

Returns:

this < all right

ltAny

public BooleanExpression ltAny(CollectionExpression<?,? super T> right)

Create a this < any right expression

Parameters:

right - rhs

Returns:

this < any right

max

public NumberExpression<T> max()

Create a max(this) expression

Get the maximum value of this expression (aggregation)

Overrides:

max in class ComparableExpressionBase<T extends Number & Comparable<?>>

Returns:

max(this)

min

public NumberExpression<T> min()

Create a min(this) expression

Get the minimum value of this expression (aggregation)

Overrides:

min in class ComparableExpressionBase<T extends Number & Comparable<?>>

Returns:

min(this)

mod

public NumberExpression<T> mod(Expression<T> num)

Create a mod(this, num) expression

Parameters:

num -

Returns:

mod(this, num)

mod

public NumberExpression<T> mod(T num)

Create a mod(this, num) expression

Parameters:

num -

Returns:

mod(this, num)

multiply

public <N extends Number & Comparable<?>>
NumberExpression<T> multiply(Expression<N> right)

Create a this * right expression

Get the result of the operation this * right

Parameters:

right -

Returns:

this * right

multiply

public <N extends Number & Comparable<N>>
NumberExpression<T> multiply(N right)

Create a this * right expression

Get the result of the operation this * right

Parameters:

right -

Returns:

this * right

negate

public NumberExpression<T> negate()

Create a this * -1 expression

Get the negation of this expression

Returns:

this * -1

round

public NumberExpression<T> round()

Create a round(this) expression

Returns the closest int to this.

Returns:

round(this)

See Also:

• Math.round(double)
• Math.round(float)

shortValue

public NumberExpression<Short> shortValue()

Create a this.shortValue() expression

Get the short expression of this numeric expression

Returns:

this.shortValue()

See Also:

• Number.shortValue()

sqrt

public NumberExpression<Double> sqrt()

Create a sqrt(this) expression

Get the square root of this numeric expressions

Returns:

sqrt(this)

subtract

public <N extends Number & Comparable<?>>
NumberExpression<T> subtract(Expression<N> right)

Create a this - right expression

Get the difference of this and right

Parameters:

right -

Returns:

this - right

subtract

public <N extends Number & Comparable<?>>
NumberExpression<T> subtract(N right)

Create a this - right expression

Get the difference of this and right

Parameters:

right -

Returns:

this - right

sum

public NumberExpression<T> sum()

Create a sum(this) expression

Get the sum of this expression (aggregation)

Returns:

sum(this)

in

public BooleanExpression in(Number... numbers)

Description copied from class: SimpleExpression

Create a this in right expression

Overrides:

in in class SimpleExpression<T extends Number & Comparable<?>>

Parameters:

numbers - rhs of the comparison

Returns:

this in right

notIn

public BooleanExpression notIn(Number... numbers)

Description copied from class: SimpleExpression

Create a this not in right expression

Overrides:

notIn in class SimpleExpression<T extends Number & Comparable<?>>

Parameters:

numbers - rhs of the comparison

Returns:

this not in right

nullif

public NumberExpression<T> nullif(Expression<T> other)

Create a nullif(this, other) expression

Overrides:

nullif in class ComparableExpressionBase<T extends Number & Comparable<?>>

Parameters:

other -

Returns:

nullif(this, other)

nullif

public NumberExpression<T> nullif(T other)

Create a nullif(this, other) expression

Overrides:

nullif in class ComparableExpressionBase<T extends Number & Comparable<?>>

Parameters:

other -

Returns:

nullif(this, other)

coalesce

public NumberExpression<T> coalesce(Expression<T> expr)

Create a coalesce(this, expr) expression

Overrides:

coalesce in class ComparableExpressionBase<T extends Number & Comparable<?>>

Parameters:

expr - additional argument

Returns:

coalesce

coalesce

public NumberExpression<T> coalesce(Expression<?>... exprs)

Create a coalesce(this, exprs...) expression

Overrides:

coalesce in class ComparableExpressionBase<T extends Number & Comparable<?>>

Parameters:

exprs - additional arguments

Returns:

coalesce

coalesce

public NumberExpression<T> coalesce(T arg)

Create a coalesce(this, arg) expression

Overrides:

coalesce in class ComparableExpressionBase<T extends Number & Comparable<?>>

Parameters:

arg - additional argument

Returns:

coalesce

coalesce

public NumberExpression<T> coalesce(T... args)

Create a coalesce(this, args...) expression

Overrides:

coalesce in class ComparableExpressionBase<T extends Number & Comparable<?>>

Parameters:

args - additional arguments

Returns:

coalesce