NumberExpression (Querydsl 4.1.4 API)

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 and Description

NumberExpression(Expression<T> mixin)

Constructors
Constructor and Description
`NumberExpression(Expression<T> mixin)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and 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
`<A extends Number & Comparable<?>> BooleanExpression`	`between(A from, A to)` Create a `this between from and to` expression
`<A extends Number & Comparable<?>> BooleanExpression`	`between(Expression<A> from, Expression<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
`<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
`<A extends Number & Comparable<?>> BooleanExpression`	`goe(A right)` Create a `this >= right` expression
`<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
`<A extends Number & Comparable<?>> BooleanExpression`	`gt(A right)` Create a `this > right` expression
`<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
`<A extends Number & Comparable<?>> BooleanExpression`	`loe(A right)` Create a `this <= right` expression
`<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
`<A extends Number & Comparable<?>> BooleanExpression`	`lt(A right)` Create a `this < right` expression
`<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
`<A extends Number & Comparable<?>> BooleanExpression`	`notBetween(A from, A to)` Create a `this not between from and to` expression
`<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
`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, coalesce, coalesce, 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, nullif, nullif, 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 Detail
  - NumberExpression
```
public NumberExpression(Expression<T> mixin)
```
- Method Detail
  - 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
                                                                          Expression<A> from,
                                                                          @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)
    
    Returns:
    
    max(this)
  - min
```
public NumberExpression<T> min()
```
    Create a min(this) expression
    Get the minimum value of this expression (aggregation)
    
    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

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

Field Summary

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

Constructor Summary

Method Summary

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

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

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

Methods inherited from class java.lang.Object

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

Constructor Detail

NumberExpression

Method Detail

max

min

random

as

as

stringValue

abs

add

add

avg

byteValue

castToNum

ceil

divide

divide

doubleValue

floatValue

floor

goe

goe

goeAll

goeAny

gt

gt

gtAll

gtAny

gtAll

gtAny

between

between

notBetween

notBetween

intValue

like

like

loe

loe

loeAll

loeAny

longValue

lt

lt

ltAll

ltAny

max

min

mod

mod

multiply

multiply

negate

round

shortValue

sqrt

subtract

subtract

sum

in

notIn