NumberExpression (Querydsl 3.4.3 API)

java.lang.Object
- com.mysema.query.types.expr.DslExpression<T>
- - com.mysema.query.types.expr.SimpleExpression<T>
  - - com.mysema.query.types.expr.ComparableExpressionBase<T>
    - - com.mysema.query.types.expr.NumberExpression<T>

Type Parameters:
T - expression type

All Implemented Interfaces:

Expression<T>, Serializable

Direct Known Subclasses:

NumberOperation, NumberPath, NumberSubQuery, 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.mysema.query.types.expr.DslExpression
  hashCode, mixin

Constructor Summary

Constructors
Constructor and Description

NumberExpression(Expression<T> mixin)

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

Method Summary

Methods
Modifier and Type	Method and Description
`NumberExpression<T>`	`abs()` Get the absolute value of this expression
`<N extends Number & Comparable<?>> NumberExpression<T>`	`add(Expression<N> right)` Get the sum of this and right
`<N extends Number & Comparable<N>> NumberExpression<T>`	`add(N right)` Get the sum of this and right
`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()` Get the average value of this expression (aggregation)
`<A extends Number & Comparable<?>> BooleanExpression`	`between(A from, A to)` Create a `from < this < to` expression
`<A extends Number & Comparable<?>> BooleanExpression`	`between(Expression<A> from, Expression<A> to)` Create a `from < this < to` expression
`NumberExpression<Byte>`	`byteValue()` Get the byte expression of this numeric expression
`<A extends Number & Comparable<? super A>> NumberExpression<A>`	`castToNum(Class<A> type)` Create a cast expression to the given numeric type
`NumberExpression<T>`	`ceil()` 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
`<N extends Number & Comparable<?>> NumberExpression<T>`	`divide(Expression<N> right)` Get the result of the operation this / right
`<N extends Number & Comparable<?>> NumberExpression<T>`	`divide(N right)` Get the result of the operation this / right
`NumberExpression<Double>`	`doubleValue()` Get the double expression of this numeric expression
`NumberExpression<Float>`	`floatValue()` Get the float expression of this numeric expression
`NumberExpression<T>`	`floor()` 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.
`<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)`
`BooleanExpression`	`goeAny(CollectionExpression<?,? super T> right)`
`<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)`
`BooleanExpression`	`gtAny(CollectionExpression<?,? super T> right)`
`BooleanExpression`	`in(Number... numbers)` Get a `this in right` expression
`NumberExpression<Integer>`	`intValue()` Get the int expression of this numeric expression
`BooleanExpression`	`like(Expression<String> str)` Expr: `this like str`
`BooleanExpression`	`like(String str)` Expr: `this like str`
`<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)`
`BooleanExpression`	`loeAny(CollectionExpression<?,? super T> right)`
`NumberExpression<Long>`	`longValue()` Get the long expression of this numeric 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)`
`BooleanExpression`	`ltAny(CollectionExpression<?,? super T> right)`
`NumberExpression<T>`	`max()` Get the maximum value of this expression (aggregation)
`static <A extends Number & Comparable<?>> NumberExpression<A>`	`max(Expression<A> left, Expression<A> right)` Return the greater of the given values
`NumberExpression<T>`	`min()` Get the minimum value of this expression (aggregation)
`static <A extends Number & Comparable<?>> NumberExpression<A>`	`min(Expression<A> left, Expression<A> right)` Return the smaller of the given values
`NumberExpression<T>`	`mod(Expression<T> num)`
`NumberExpression<T>`	`mod(T num)`
`<N extends Number & Comparable<?>> NumberExpression<T>`	`multiply(Expression<N> right)` Get the result of the operation this * right
`<N extends Number & Comparable<N>> NumberExpression<T>`	`multiply(N right)` Get the result of the operation this * right
`NumberExpression<T>`	`negate()` Get the negation of this expression
`<A extends Number & Comparable<?>> BooleanExpression`	`notBetween(A from, A to)`
`<A extends Number & Comparable<?>> BooleanExpression`	`notBetween(Expression<A> from, Expression<A> to)`
`BooleanExpression`	`notIn(Number... numbers)` Get a `this not in right` expression
`static NumberExpression<Double>`	`random()` Returns the random expression
`NumberExpression<T>`	`round()` Returns the closest `int` to the argument.
`NumberExpression<Short>`	`shortValue()` Get the short expression of this numeric expression
`NumberExpression<Double>`	`sqrt()` Get the square root of this numeric expressions
`<N extends Number & Comparable<?>> NumberExpression<T>`	`subtract(Expression<N> right)` Get the difference of this and right
`<N extends Number & Comparable<?>> NumberExpression<T>`	`subtract(N right)` Get the difference of this and right
`NumberExpression<T>`	`sum()` Get the sum of this expression (aggregation)

Methods inherited from class com.mysema.query.types.expr.ComparableExpressionBase
asc, coalesce, coalesce, desc, stringValue

Methods inherited from class com.mysema.query.types.expr.SimpleExpression
count, countDistinct, eq, eq, eqAll, eqAny, in, in, isNotNull, isNull, ne, ne, neAll, neAny, notIn, notIn, nullif, nullif, when, when

Methods inherited from class com.mysema.query.types.expr.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.mysema.query.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)
```
  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)
```
  Return the smaller of the given values
  
  Returns:
  min(left, right)
- random
```
public static NumberExpression<Double> random()
```
  Returns the random expression
  
  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:
- 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:
- abs
```
public NumberExpression<T> abs()
```
  Get the absolute value of this expression
  
  Returns:
  abs(this)
- add
```
public <N extends Number & Comparable<?>> NumberExpression<T> add(Expression<N> right)
```
  Get the sum of this and right
  
  Parameters:
  right -
  
  Returns:
  this + right
- add
```
public <N extends Number & Comparable<N>> NumberExpression<T> add(N right)
```
  Get the sum of this and right
  
  Parameters:
  right -
  
  Returns:
  this + right
- avg
```
public NumberExpression<Double> avg()
```
  Get the average value of this expression (aggregation)
  
  Returns:
  avg(this)
- byteValue
```
public NumberExpression<Byte> byteValue()
```
  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)
```
  Description copied from class: ComparableExpressionBase
  
  Create a cast expression to the given numeric type
  
  Overrides:
  
  castToNum in class ComparableExpressionBase<T extends Number & Comparable<?>>
  
  Returns:
- ceil
```
public NumberExpression<T> ceil()
```
  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)
```
  Get the result of the operation this / right
  
  Parameters:
  right -
  
  Returns:
  this / right
- divide
```
public <N extends Number & Comparable<?>> NumberExpression<T> divide(N right)
```
  Get the result of the operation this / right
  
  Parameters:
  right -
  
  Returns:
  this / right
- doubleValue
```
public NumberExpression<Double> doubleValue()
```
  Get the double expression of this numeric expression
  
  Returns:
  this.doubleValue()
  See Also:
  Number.doubleValue()
- floatValue
```
public NumberExpression<Float> floatValue()
```
  Get the float expression of this numeric expression
  
  Returns:
  this.floatValue()
  See Also:
  Number.floatValue()
- floor
```
public NumberExpression<T> floor()
```
  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)
```
  Parameters:
  right -
  
  Returns:
- goeAny
```
public BooleanExpression goeAny(CollectionExpression<?,? super T> right)
```
  Parameters:
  right -
  
  Returns:
- 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)
```
  Parameters:
  right -
  
  Returns:
- gtAny
```
public BooleanExpression gtAny(CollectionExpression<?,? super T> right)
```
  Parameters:
  right -
  
  Returns:
- between
```
public final <A extends Number & Comparable<?>> BooleanExpression between(@Nullable
                                                          A from,
                                                          @Nullable
                                                          A to)
```
  Create a from < this < to expression
  
  Type Parameters:
  A -
  Parameters:
  from -
  to -
  
  Returns:
- between
```
public final <A extends Number & Comparable<?>> BooleanExpression between(@Nullable
                                                          Expression<A> from,
                                                          @Nullable
                                                          Expression<A> to)
```
  Create a from < this < to expression
  
  Type Parameters:
  A -
  Parameters:
  from -
  to -
  
  Returns:
- notBetween
```
public final <A extends Number & Comparable<?>> BooleanExpression notBetween(A from,
                                                             A to)
```
  Parameters:
  from -
  to -
  
  Returns:
- notBetween
```
public final <A extends Number & Comparable<?>> BooleanExpression notBetween(Expression<A> from,
                                                             Expression<A> to)
```
  Parameters:
  from -
  to -
  
  Returns:
- intValue
```
public NumberExpression<Integer> intValue()
```
  Get the int expression of this numeric expression
  
  Returns:
  this.intValue()
  See Also:
  Number.intValue()
- like
```
public BooleanExpression like(String str)
```
  Expr: this like str
  
  Parameters:
  str -
  
  Returns:
- like
```
public BooleanExpression like(Expression<String> str)
```
  Expr: this like str
  
  Parameters:
  str -
  
  Returns:
- 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)
```
  Parameters:
  right -
  
  Returns:
- loeAny
```
public BooleanExpression loeAny(CollectionExpression<?,? super T> right)
```
  Parameters:
  right -
  
  Returns:
- longValue
```
public NumberExpression<Long> longValue()
```
  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)
```
  Parameters:
  right -
  
  Returns:
- ltAny
```
public BooleanExpression ltAny(CollectionExpression<?,? super T> right)
```
  Parameters:
  right -
  
  Returns:
- max
```
public NumberExpression<T> max()
```
  Get the maximum value of this expression (aggregation)
  
  Returns:
  max(this)
- min
```
public NumberExpression<T> min()
```
  Get the minimum value of this expression (aggregation)
  
  Returns:
  min(this)
- mod
```
public NumberExpression<T> mod(Expression<T> num)
```
  Parameters:
  num -
  
  Returns:
- mod
```
public NumberExpression<T> mod(T num)
```
  Parameters:
  num -
  
  Returns:
- multiply
```
public <N extends Number & Comparable<?>> NumberExpression<T> multiply(Expression<N> right)
```
  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)
```
  Get the result of the operation this * right
  
  Parameters:
  right -
  
  Returns:
  this * right
- negate
```
public NumberExpression<T> negate()
```
  Get the negation of this expression
  
  Returns:
  this * -1
- round
```
public NumberExpression<T> round()
```
  Returns the closest int to the argument.
  
  Returns:
  round(this)
  See Also:
  Math.round(double), Math.round(float)
- shortValue
```
public NumberExpression<Short> shortValue()
```
  Get the short expression of this numeric expression
  
  Returns:
  this.shortValue()
  See Also:
  Number.shortValue()
- sqrt
```
public NumberExpression<Double> sqrt()
```
  Get the square root of this numeric expressions
  
  Returns:
  sqrt(this)
- subtract
```
public <N extends Number & Comparable<?>> NumberExpression<T> subtract(Expression<N> right)
```
  Get the difference of this and right
  
  Parameters:
  right -
  
  Returns:
  this - right
- subtract
```
public <N extends Number & Comparable<?>> NumberExpression<T> subtract(N right)
```
  Get the difference of this and right
  
  Parameters:
  right -
  
  Returns:
  this - right
- sum
```
public NumberExpression<T> sum()
```
  Get the sum of this expression (aggregation)
  
  Returns:
  sum(this)
- in
```
public BooleanExpression in(Number... numbers)
```
  Description copied from class: SimpleExpression
  
  Get a this in right expression
  
  Overrides:
  
  in in class SimpleExpression<T extends Number & Comparable<?>>
  
  Parameters:
  numbers - rhs of the comparison
  
  Returns:
- notIn
```
public BooleanExpression notIn(Number... numbers)
```
  Description copied from class: SimpleExpression
  
  Get a this not in right expression
  
  Overrides:
  
  notIn in class SimpleExpression<T extends Number & Comparable<?>>
  
  Parameters:
  numbers - rhs of the comparison
  
  Returns:

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

Field Summary

Fields inherited from class com.mysema.query.types.expr.DslExpression

Constructor Summary

Method Summary

Methods inherited from class com.mysema.query.types.expr.ComparableExpressionBase

Methods inherited from class com.mysema.query.types.expr.SimpleExpression

Methods inherited from class com.mysema.query.types.expr.DslExpression

Methods inherited from class java.lang.Object

Methods inherited from interface com.mysema.query.types.Expression

Constructor Detail

NumberExpression

Method Detail

max

min

random

as

as

abs

add

add

avg

byteValue

castToNum

ceil

divide

divide

doubleValue

floatValue

floor

goe

goe

goeAll

goeAny

gt

gt

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