mirror of
https://github.com/querydsl/querydsl.git
synced 2026-06-30 21:08:30 +08:00
This commit is contained in:
Timo Westkämper
parent
0f4b168419
commit
832f272883
1975
querydsl-scala/log
Normal file
1975
querydsl-scala/log
Normal file
File diff suppressed because it is too large
Load Diff
@ -26,10 +26,10 @@
|
||||
<version>${project.parent.version}</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.scala-lang</groupId>
|
||||
<artifactId>scala-library</artifactId>
|
||||
<version>${scala.version}</version>
|
||||
<scope>provided</scope>
|
||||
<groupId>org.scala-lang</groupId>
|
||||
<artifactId>scala-library</artifactId>
|
||||
<version>${scala.version}</version>
|
||||
<scope>provided</scope>
|
||||
</dependency>
|
||||
|
||||
<!-- provided -->
|
||||
@ -116,7 +116,14 @@
|
||||
<plugins>
|
||||
<plugin>
|
||||
<groupId>org.scala-tools</groupId>
|
||||
<artifactId>maven-scala-plugin</artifactId>
|
||||
<artifactId>maven-scala-plugin</artifactId>
|
||||
<!--
|
||||
<configuration>
|
||||
<args>
|
||||
<arg>-Xprint:typer</arg>
|
||||
</args>
|
||||
</configuration>
|
||||
-->
|
||||
<executions>
|
||||
<execution>
|
||||
<goals>
|
||||
|
||||
@ -29,21 +29,21 @@ object Conversions {
|
||||
|
||||
def not(b: BooleanExpression) = b.not;
|
||||
|
||||
def count(e: SimpleExpression[_]) = e.$count();
|
||||
def count(e: SimpleExpression[_]) = e.count();
|
||||
|
||||
def min(e: NumberExpression[_]) = e.$min();
|
||||
def min(e: NumberExpression[_]) = e.min();
|
||||
|
||||
def max(e: NumberExpression[_]) = e.$max();
|
||||
def max(e: NumberExpression[_]) = e.max();
|
||||
|
||||
def sum(e: NumberExpression[_]) = e.$sum();
|
||||
def sum(e: NumberExpression[_]) = e.sum();
|
||||
|
||||
def avg(e: NumberExpression[_]) = e.$avg();
|
||||
def avg(e: NumberExpression[_]) = e.avg();
|
||||
|
||||
// implicit conversions
|
||||
|
||||
implicit def arrayPath[T <: Array[_]](a: T): ArrayPath[T] = aliasFactory.getCurrentAndReset();
|
||||
|
||||
implicit def booleanPath(b: java.lang.Boolean): BooleanExpression = aliasFactory.getCurrentAndReset();
|
||||
implicit def booleanPath(b: java.lang.Boolean): BooleanFunctions = aliasFactory.getCurrentAndReset();
|
||||
|
||||
implicit def stringPath(s: String): StringPath = aliasFactory.getCurrentAndReset();
|
||||
|
||||
|
||||
@ -52,68 +52,68 @@ object Resolver {
|
||||
|
||||
}
|
||||
|
||||
trait SimpleExpression[T] {
|
||||
trait SimpleExpression[T] extends Expression[T]{
|
||||
|
||||
def expr: Expression[T];
|
||||
|
||||
def getType(): Class[_ <: T];
|
||||
|
||||
// TODO : get rid of asInstanceOf
|
||||
def $as(right: Path[T]): SimpleExpression[T] = simple(getType, ALIAS.asInstanceOf[Operator[T]], expr, right);
|
||||
def as(right: Path[T]): SimpleExpression[T] = simple(getType, ALIAS.asInstanceOf[Operator[T]], this, right);
|
||||
|
||||
def $as(alias: String): SimpleExpression[T] = $as(new PathImpl[T](getType, alias));
|
||||
def as(alias: String): SimpleExpression[T] = as(new PathImpl[T](getType, alias));
|
||||
|
||||
def is(right: T): BooleanExpression = $eq(resolve(right)); // XXX "is"
|
||||
def is(right: T): BooleanExpression = $eq(right);
|
||||
|
||||
def is(right: Expression[T]) = $eq(right);
|
||||
|
||||
def $eq(right: T): BooleanExpression = $eq(resolve(right)); // XXX "is"
|
||||
|
||||
def $eq(right: Expression[T]) = boolean(EQ_OBJECT, expr, right); // XXX "is"
|
||||
def $eq(right: Expression[T]) = boolean(EQ_OBJECT, this, right); // XXX "is"
|
||||
|
||||
def <>(right: T): BooleanExpression = $ne(right);
|
||||
|
||||
def <>(right: Expression[T]) = $ne(right);
|
||||
|
||||
def $ne(right: T): BooleanExpression = $ne(resolve(right)); // XXX "<>" / "isnt" / "isNot"
|
||||
|
||||
def $ne(right: Expression[T]) = boolean(NE_OBJECT, expr, right); // XXX "isNot"
|
||||
def $ne(right: Expression[T]) = boolean(NE_OBJECT, this, right); // XXX "isNot"
|
||||
|
||||
def $count() = number[java.lang.Long](classOf[java.lang.Long], AggOps.COUNT_AGG, expr);
|
||||
def count() = number[java.lang.Long](classOf[java.lang.Long], AggOps.COUNT_AGG, this);
|
||||
|
||||
def $in(right: Collection[T]) = boolean(IN, expr, resolve(right));
|
||||
def in(right: Collection[T]) = boolean(IN, this, resolve(right));
|
||||
|
||||
def $in(right: T*): BooleanExpression = $in(asList(right: _*));
|
||||
def in(right: T*): BooleanExpression = in(asList(right: _*));
|
||||
|
||||
def $in(right: CollectionExpression[T]) = boolean(IN, expr, right);
|
||||
def in(right: CollectionExpression[T]) = boolean(IN, this, right);
|
||||
|
||||
def $countDistinct() = number[java.lang.Long](classOf[java.lang.Long], AggOps.COUNT_DISTINCT_AGG, expr);
|
||||
def countDistinct() = number[java.lang.Long](classOf[java.lang.Long], AggOps.COUNT_DISTINCT_AGG, this);
|
||||
|
||||
def $isNotNull() = boolean(IS_NOT_NULL, expr);
|
||||
def isNotNull() = boolean(IS_NOT_NULL, this);
|
||||
|
||||
def $isNull() = boolean(IS_NULL, expr);
|
||||
def isNull() = boolean(IS_NULL, this);
|
||||
|
||||
def $notIn(right: Collection[T]) = $in(right).not;
|
||||
def notIn(right: Collection[T]) = in(right).not;
|
||||
|
||||
def $notIn(right: T*) = $in(right: _*).not;
|
||||
def notIn(right: T*) = in(right: _*).not;
|
||||
|
||||
def $notIn(right: CollectionExpression[T]) = $in(right).not;
|
||||
def notIn(right: CollectionExpression[T]) = in(right).not;
|
||||
|
||||
}
|
||||
|
||||
trait ArrayExpression[T <: Array[_]] extends SimpleExpression[T] {
|
||||
|
||||
def $size() = number[Integer](classOf[Integer], Ops.ARRAY_SIZE, expr);
|
||||
|
||||
// def $get(index: Integer) = Paths.simple(getType.getComponentType, forArrayAccess(this, index.intValue));
|
||||
def size() = number[Integer](classOf[Integer], Ops.ARRAY_SIZE, this);
|
||||
|
||||
}
|
||||
|
||||
trait CollectionExpressionBase[T <: Collection[C], C] extends SimpleExpression[T] with com.mysema.query.types.CollectionExpression[T,C] {
|
||||
|
||||
def $size() = number[Integer](classOf[Integer], COL_SIZE, this);
|
||||
def size() = number[Integer](classOf[Integer], COL_SIZE, this);
|
||||
|
||||
def $isEmpty() = boolean(COL_IS_EMPTY, this);
|
||||
def isEmpty() = boolean(COL_IS_EMPTY, this);
|
||||
|
||||
def $isNotEmpty() = $isEmpty().not;
|
||||
def isNotEmpty() = isEmpty().not;
|
||||
|
||||
def $contains(child: C) = boolean(IN, resolve(child), this);
|
||||
def contains(child: C) = boolean(IN, resolve(child), this);
|
||||
|
||||
def $contains(child: Expression[C]) = boolean(IN, child, this);
|
||||
def contains(child: Expression[C]) = boolean(IN, child, this);
|
||||
|
||||
}
|
||||
|
||||
trait CollectionExpression[T] extends CollectionExpressionBase[java.util.Collection[T], T] {}
|
||||
@ -126,60 +126,75 @@ trait ListExpression[T] extends CollectionExpressionBase[java.util.List[T], T] {
|
||||
|
||||
trait MapExpression[K, V] extends SimpleExpression[java.util.Map[K, V]] with com.mysema.query.types.MapExpression[K,V] {
|
||||
|
||||
def $size() = number[Integer](classOf[Integer], MAP_SIZE, this);
|
||||
def size() = number[Integer](classOf[Integer], MAP_SIZE, this);
|
||||
|
||||
def $isEmpty() = boolean(MAP_IS_EMPTY, this);
|
||||
def isEmpty() = boolean(MAP_IS_EMPTY, this);
|
||||
|
||||
def $isNotEmpty() = $isEmpty().not;
|
||||
def isNotEmpty() = isEmpty().not;
|
||||
|
||||
def $containsKey(k: K) = boolean(CONTAINS_KEY, this, resolve(k));
|
||||
def containsKey(k: K) = boolean(CONTAINS_KEY, this, resolve(k));
|
||||
|
||||
def $containsKey(k: Expression[K]) = boolean(CONTAINS_KEY, this, k);
|
||||
def containsKey(k: Expression[K]) = boolean(CONTAINS_KEY, this, k);
|
||||
|
||||
def $containsValue(v: V) = boolean(CONTAINS_KEY, this, resolve(v));
|
||||
def containsValue(v: V) = boolean(CONTAINS_KEY, this, resolve(v));
|
||||
|
||||
def $containsValue(v: Expression[V]) = boolean(CONTAINS_KEY, this, v);
|
||||
def containsValue(v: Expression[V]) = boolean(CONTAINS_KEY, this, v);
|
||||
|
||||
}
|
||||
|
||||
trait ComparableExpressionBase[T <: Comparable[_]] extends SimpleExpression[T] {
|
||||
|
||||
def asc() = new OrderSpecifier[T](Order.ASC, expr);
|
||||
def asc() = new OrderSpecifier[T](Order.ASC, this);
|
||||
|
||||
def desc() = new OrderSpecifier[T](Order.DESC, expr);
|
||||
def desc() = new OrderSpecifier[T](Order.DESC, this);
|
||||
|
||||
}
|
||||
|
||||
trait ComparableExpression[T <: Comparable[_]] extends ComparableExpressionBase[T] {
|
||||
|
||||
def $lt(right: T): BooleanExpression = $lt(resolve(right));
|
||||
def <(right: T): BooleanExpression = lt(right);
|
||||
|
||||
def $lt(right: Expression[T]): BooleanExpression = boolean(BEFORE, expr, right);
|
||||
def <(right: Expression[T]): BooleanExpression = lt(right);
|
||||
|
||||
def $between(left: T, right: T): BooleanExpression = $between(resolve(left), resolve(right));
|
||||
def >(right: T): BooleanExpression = gt(right);
|
||||
|
||||
def $between(left: Expression[T], right: Expression[T]) = boolean(BETWEEN, expr, left, right); ;
|
||||
def >(right: Expression[T]) = gt(right);
|
||||
|
||||
def >=(right: T): BooleanExpression = goe(right);
|
||||
|
||||
def $notBetween(left: T, right: T): BooleanExpression = $notBetween(resolve(left), resolve(right));
|
||||
def >=(right: Expression[T]) = goe(right);
|
||||
|
||||
def <=(right: T): BooleanExpression = loe(right);
|
||||
|
||||
def $notBetween(left: Expression[T], right: Expression[T]) = $between(left, right).not;
|
||||
def <=(right: Expression[T]) = loe(right);
|
||||
|
||||
def lt(right: T): BooleanExpression = lt(resolve(right));
|
||||
|
||||
def $gt(right: T): BooleanExpression = $gt(resolve(right));
|
||||
def lt(right: Expression[T]): BooleanExpression = boolean(BEFORE, this, right);
|
||||
|
||||
def $gt(right: Expression[T]) = boolean(AFTER, expr, right);
|
||||
def between(left: T, right: T): BooleanExpression = between(resolve(left), resolve(right));
|
||||
|
||||
def $goe(right: T): BooleanExpression = $goe(resolve(right));
|
||||
def between(left: Expression[T], right: Expression[T]) = boolean(BETWEEN, this, left, right); ;
|
||||
|
||||
def $goe(right: Expression[T]) = boolean(AOE, expr, right);
|
||||
def notBetween(left: T, right: T): BooleanExpression = notBetween(resolve(left), resolve(right));
|
||||
|
||||
def $loe(right: T): BooleanExpression = $loe(resolve(right));
|
||||
def notBetween(left: Expression[T], right: Expression[T]) = between(left, right).not;
|
||||
|
||||
def gt(right: T): BooleanExpression = gt(resolve(right));
|
||||
|
||||
def $loe(right: Expression[T]) = boolean(BOE, expr, right);
|
||||
def gt(right: Expression[T]) = boolean(AFTER, this, right);
|
||||
|
||||
def goe(right: T): BooleanExpression = goe(resolve(right));
|
||||
|
||||
// TODO : get rid of asInstanceOf
|
||||
override def $as(right: Path[T]) = comparable(getType, ALIAS.asInstanceOf[Operator[T]], expr, right);
|
||||
def goe(right: Expression[T]) = boolean(AOE, this, right);
|
||||
|
||||
def loe(right: T): BooleanExpression = loe(resolve(right));
|
||||
|
||||
override def $as(alias: String): ComparableExpression[T] = $as(new PathImpl[T](getType, alias));
|
||||
def loe(right: Expression[T]) = boolean(BOE, this, right);
|
||||
|
||||
override def as(right: Path[T]) = comparable(getType, ALIAS.asInstanceOf[Operator[T]], this, right);
|
||||
|
||||
override def as(alias: String): ComparableExpression[T] = as(new PathImpl[T](getType, alias));
|
||||
|
||||
}
|
||||
|
||||
@ -189,69 +204,83 @@ trait NumberExpression[T <: Number with Comparable[T]] extends ComparableExpress
|
||||
|
||||
type NumberArray = Array[_ <: Number]
|
||||
|
||||
def $add(right: NumberExpr) = number[T](getType, ADD, expr, right);
|
||||
def <(right: Number): BooleanExpression = lt(right);
|
||||
|
||||
def $add(right: Number): NumberExpression[T] = $add(resolve(right));
|
||||
def <(right: NumberExpr): BooleanExpression = lt(right);
|
||||
|
||||
def $goe(right: Number): BooleanExpression = $goe(resolve(right));
|
||||
def >(right: Number): BooleanExpression = gt(right);
|
||||
|
||||
def $goe(right: NumberExpr) = boolean(Ops.GOE, expr, right);
|
||||
|
||||
def $gt(right: Number): BooleanExpression = $gt(resolve(right));
|
||||
|
||||
def $gt(right: NumberExpr) = boolean(Ops.GT, expr, right);
|
||||
|
||||
def $between(left: Number, right: Number) = boolean(Ops.BETWEEN, expr, resolve(left), resolve(right));
|
||||
|
||||
def $between(left: NumberExpr, right: NumberExpr) = boolean(Ops.BETWEEN, expr, left, right);
|
||||
|
||||
def $notBetween(left: Number, right: Number): BooleanExpression = $between(left, right).not;
|
||||
|
||||
def $notBetween(left: NumberExpr, right: NumberExpr) = $between(left, right).not;
|
||||
|
||||
def $loe(right: Number): BooleanExpression = $loe(resolve(right));
|
||||
|
||||
def $loe(right: NumberExpr) = boolean(Ops.LOE, expr, right);
|
||||
|
||||
def <(right: Number): BooleanExpression = $lt(resolve(right));
|
||||
def >(right: NumberExpr) = gt(right);
|
||||
|
||||
def $lt(right: Number): BooleanExpression = $lt(resolve(right));
|
||||
def >=(right: Number): BooleanExpression = goe(right);
|
||||
|
||||
def $lt(right: NumberExpr) = boolean(Ops.LT, expr, right);
|
||||
def >=(right: NumberExpr) = goe(right);
|
||||
|
||||
def <=(right: Number): BooleanExpression = loe(right);
|
||||
|
||||
def $in(right: NumberArray) = boolean(IN, expr, resolve(asList(right: _*)));
|
||||
def <=(right: NumberExpr) = loe(right);
|
||||
|
||||
def add(right: NumberExpr) = number[T](getType, ADD, this, right);
|
||||
|
||||
def $min() = number[T](getType, AggOps.MIN_AGG, expr);
|
||||
def add(right: Number): NumberExpression[T] = add(resolve(right));
|
||||
|
||||
def $max() = number[T](getType, AggOps.MAX_AGG, expr);
|
||||
def goe(right: Number): BooleanExpression = goe(resolve(right));
|
||||
|
||||
def $sum() = number[T](getType, AggOps.SUM_AGG, expr);
|
||||
def goe(right: NumberExpr) = boolean(Ops.GOE, this, right);
|
||||
|
||||
def $avg() = number[T](getType, AggOps.AVG_AGG, expr);
|
||||
def gt(right: Number): BooleanExpression = gt(resolve(right));
|
||||
|
||||
def $subtract(right: NumberExpr) = number[T](getType, Ops.SUB, expr, right);
|
||||
def gt(right: NumberExpr) = boolean(Ops.GT, this, right);
|
||||
|
||||
def $subtract(right: Number): NumberExpression[T] = $subtract(resolve(right));
|
||||
def between(left: Number, right: Number) = boolean(Ops.BETWEEN, this, resolve(left), resolve(right));
|
||||
|
||||
def $notIn(right: NumberArray) = boolean(IN, expr, resolve(asList(right: _*))).not;
|
||||
def between(left: NumberExpr, right: NumberExpr) = boolean(Ops.BETWEEN, this, left, right);
|
||||
|
||||
def $divide(right: NumberExpr) = number[T](getType, Ops.DIV, expr, right);
|
||||
def notBetween(left: Number, right: Number): BooleanExpression = between(left, right).not;
|
||||
|
||||
def $divide(right: Number): NumberExpression[T] = $divide(resolve(right));
|
||||
def notBetween(left: NumberExpr, right: NumberExpr) = between(left, right).not;
|
||||
|
||||
def $multiply(right: NumberExpr) = number[T](getType, Ops.MULT, expr, right);
|
||||
def loe(right: Number): BooleanExpression = loe(resolve(right));
|
||||
|
||||
def $multiply(right: Number): NumberExpression[T] = $multiply(resolve(right));
|
||||
def loe(right: NumberExpr) = boolean(Ops.LOE, this, right);
|
||||
|
||||
def lt(right: Number): BooleanExpression = lt(resolve(right));
|
||||
|
||||
def $negate() = $multiply(-1);
|
||||
def lt(right: NumberExpr) = boolean(Ops.LT, this, right);
|
||||
|
||||
def $mod(right: NumberExpr) = number[T](getType, Ops.MOD, expr, right);
|
||||
def in(right: NumberArray) = boolean(IN, this, resolve(asList(right: _*)));
|
||||
|
||||
def $mod(right: Number): NumberExpression[T] = $mod(resolve(right));
|
||||
def min() = number[T](getType, AggOps.MIN_AGG, this);
|
||||
|
||||
def $sqrt() = number[java.lang.Double](classOf[java.lang.Double], MathOps.SQRT, expr);
|
||||
def max() = number[T](getType, AggOps.MAX_AGG, this);
|
||||
|
||||
def $abs() = number[T](getType, MathOps.ABS, expr);
|
||||
def sum() = number[T](getType, AggOps.SUM_AGG, this);
|
||||
|
||||
def avg() = number[T](getType, AggOps.AVG_AGG, this);
|
||||
|
||||
def subtract(right: NumberExpr) = number[T](getType, Ops.SUB, this, right);
|
||||
|
||||
def subtract(right: Number): NumberExpression[T] = subtract(resolve(right));
|
||||
|
||||
def notIn(right: NumberArray) = boolean(IN, this, resolve(asList(right: _*))).not;
|
||||
|
||||
def divide(right: NumberExpr) = number[T](getType, Ops.DIV, this, right);
|
||||
|
||||
def divide(right: Number): NumberExpression[T] = divide(resolve(right));
|
||||
|
||||
def multiply(right: NumberExpr) = number[T](getType, Ops.MULT, this, right);
|
||||
|
||||
def multiply(right: Number): NumberExpression[T] = multiply(resolve(right));
|
||||
|
||||
def negate() = multiply(-1);
|
||||
|
||||
def mod(right: NumberExpr) = number[T](getType, Ops.MOD, this, right);
|
||||
|
||||
def mod(right: Number): NumberExpression[T] = mod(resolve(right));
|
||||
|
||||
def sqrt() = number[java.lang.Double](classOf[java.lang.Double], MathOps.SQRT, this);
|
||||
|
||||
def abs() = number[T](getType, MathOps.ABS, this);
|
||||
|
||||
def $byteValue() = castToNum(classOf[java.lang.Byte]);
|
||||
|
||||
@ -265,228 +294,236 @@ trait NumberExpression[T <: Number with Comparable[T]] extends ComparableExpress
|
||||
|
||||
def $shortValue() = castToNum(classOf[java.lang.Short]);
|
||||
|
||||
def $ceil() = number[T](getType, MathOps.CEIL, expr);
|
||||
def ceil() = number[T](getType, MathOps.CEIL, this);
|
||||
|
||||
def $floor() = number[T](getType, MathOps.FLOOR, expr);
|
||||
def floor() = number[T](getType, MathOps.FLOOR, this);
|
||||
|
||||
def $round() = number[T](getType, MathOps.ROUND, expr);
|
||||
def round() = number[T](getType, MathOps.ROUND, this);
|
||||
|
||||
private def castToNum[A <: Number with Comparable[A]](t: Class[A]): NumberExpression[A] = {
|
||||
if (t.equals(getType)) {
|
||||
this.asInstanceOf[NumberExpression[A]];
|
||||
} else {
|
||||
number[A](t, Ops.NUMCAST, expr, constant(t));
|
||||
number[A](t, Ops.NUMCAST, this, constant(t));
|
||||
}
|
||||
}
|
||||
|
||||
override def $as(right: Path[T]) = number(getType, ALIAS.asInstanceOf[Operator[T]], expr, right);
|
||||
override def as(right: Path[T]) = number(getType, ALIAS.asInstanceOf[Operator[T]], this, right);
|
||||
|
||||
override def $as(alias: String): NumberExpression[T] = $as(new PathImpl[T](getType, alias));
|
||||
override def as(alias: String): NumberExpression[T] = as(new PathImpl[T](getType, alias));
|
||||
|
||||
}
|
||||
|
||||
trait BooleanExpression extends ComparableExpression[java.lang.Boolean] with Predicate {
|
||||
trait BooleanFunctions {
|
||||
|
||||
def and(right: Predicate): BooleanExpression;
|
||||
|
||||
def $and(right: Predicate) = boolean(Ops.AND, this, right);
|
||||
def or(right: Predicate): BooleanExpression;
|
||||
|
||||
def $or(right: Predicate) = boolean(Ops.OR, this, right);
|
||||
def not(): BooleanExpression;
|
||||
|
||||
}
|
||||
|
||||
def $not() = not();
|
||||
trait BooleanExpression extends ComparableExpression[java.lang.Boolean] with Predicate with BooleanFunctions {
|
||||
|
||||
def and(right: Predicate) = boolean(Ops.AND, this, right);
|
||||
|
||||
def or(right: Predicate) = boolean(Ops.OR, this, right);
|
||||
|
||||
def not() = boolean(Ops.NOT, this);
|
||||
|
||||
override def $as(right: Path[java.lang.Boolean]) = boolean(ALIAS.asInstanceOf[Operator[java.lang.Boolean]], this, right);
|
||||
override def as(right: Path[java.lang.Boolean]) = boolean(ALIAS.asInstanceOf[Operator[java.lang.Boolean]], this, right);
|
||||
|
||||
override def $as(alias: String): BooleanExpression = $as(new PathImpl[java.lang.Boolean](getType, alias));
|
||||
override def as(alias: String): BooleanExpression = as(new PathImpl[java.lang.Boolean](getType, alias));
|
||||
|
||||
}
|
||||
|
||||
trait StringExpression extends ComparableExpression[String] {
|
||||
|
||||
def $like(right: String): BooleanExpression = $like(resolve(right));
|
||||
def like(right: String): BooleanExpression = like(resolve(right));
|
||||
|
||||
def $like(right: Expression[String]) = boolean(Ops.LIKE, expr, right);
|
||||
def like(right: Expression[String]) = boolean(Ops.LIKE, this, right);
|
||||
|
||||
def $append(right: Expression[String]) = string(Ops.CONCAT, expr, right); // XXX "||"
|
||||
def append(right: Expression[String]) = string(Ops.CONCAT, this, right); // XXX "||"
|
||||
|
||||
def $append(right: String): StringExpression = $append(resolve(right));
|
||||
def append(right: String): StringExpression = append(resolve(right));
|
||||
|
||||
def $concat(right: Expression[String]) = $append(right);
|
||||
def concat(right: Expression[String]) = append(right);
|
||||
|
||||
def $concat(right: String) = $append(right);
|
||||
def concat(right: String) = append(right);
|
||||
|
||||
def $prepend(right: Expression[String]) = string(Ops.CONCAT, right, expr);
|
||||
def prepend(right: Expression[String]) = string(Ops.CONCAT, right, this);
|
||||
|
||||
def $prepend(right: String): StringExpression = $prepend(resolve(right));
|
||||
def prepend(right: String): StringExpression = prepend(resolve(right));
|
||||
|
||||
def $stringValue() = this;
|
||||
def stringValue() = this;
|
||||
|
||||
def $lower() = $toLowerCase();
|
||||
def lower() = toLowerCase();
|
||||
|
||||
def $upper() = $toUpperCase();
|
||||
def upper() = toUpperCase();
|
||||
|
||||
def $matches(right: Expression[String]) = boolean(Ops.MATCHES, expr, right); // XXX "matchesExpr"
|
||||
def matches(right: Expression[String]) = boolean(Ops.MATCHES, this, right); // XXX "matchesExpr"
|
||||
|
||||
def $matches(right: String): BooleanExpression = $matches(resolve(right)); // XXX "matchesExpr"
|
||||
def matches(right: String): BooleanExpression = matches(resolve(right)); // XXX "matchesExpr"
|
||||
|
||||
def $indexOf(right: Expression[String]) = number[Integer](classOf[Integer], Ops.INDEX_OF, expr, right); // XXX "index" / "idxOf" :( (?)
|
||||
def indexOf(right: Expression[String]) = number[Integer](classOf[Integer], Ops.INDEX_OF, this, right); // XXX "index" / "idxOf" :( (?)
|
||||
|
||||
def $indexOf(right: String): NumberExpression[Integer] = $indexOf(resolve(right)); // XXX "index" (?)
|
||||
def indexOf(right: String): NumberExpression[Integer] = indexOf(resolve(right)); // XXX "index" (?)
|
||||
|
||||
def $indexOf(left: String, right: Int): NumberExpression[Integer] = $indexOf(resolve(left), right); // XXX "index" (?)
|
||||
def indexOf(left: String, right: Int): NumberExpression[Integer] = indexOf(resolve(left), right); // XXX "index" (?)
|
||||
|
||||
def $indexOf(left: Expression[String], right: Int) = number[Integer](classOf[Integer], Ops.INDEX_OF_2ARGS, expr, left, resolve(right)); // XXX "index" (?)
|
||||
def indexOf(left: Expression[String], right: Int) = number[Integer](classOf[Integer], Ops.INDEX_OF_2ARGS, this, left, resolve(right)); // XXX "index" (?)
|
||||
|
||||
def $charAt(right: Expression[Integer]) = simple(classOf[Character], Ops.CHAR_AT, expr, right); // XXX "char"
|
||||
def charAt(right: Expression[Integer]) = simple(classOf[Character], Ops.CHAR_AT, this, right); // XXX "char"
|
||||
|
||||
def $charAt(right: Integer): SimpleExpression[Character] = $charAt(resolve(right)); // XXX "char"
|
||||
def charAt(right: Integer): SimpleExpression[Character] = charAt(resolve(right)); // XXX "char"
|
||||
|
||||
def $contains(right: Expression[String]) = boolean(Ops.STRING_CONTAINS, expr, right); // XXX "has" / "haz" ;)
|
||||
def contains(right: Expression[String]) = boolean(Ops.STRING_CONTAINS, this, right); // XXX "has" / "haz" ;)
|
||||
|
||||
def $contains(right: String): BooleanExpression = $contains(resolve(right)); // XXX "has"
|
||||
def contains(right: String): BooleanExpression = contains(resolve(right)); // XXX "has"
|
||||
|
||||
def $endsWith(right: Expression[String]) = boolean(Ops.ENDS_WITH, expr, right); // XXX "ends" / "endsIn"
|
||||
def endsWith(right: Expression[String]) = boolean(Ops.ENDS_WITH, this, right); // XXX "ends" / "endsIn"
|
||||
|
||||
def $endsWith(right: String): BooleanExpression = $endsWith(resolve(right)); // XXX "ends" / "endsIn"
|
||||
def endsWith(right: String): BooleanExpression = endsWith(resolve(right)); // XXX "ends" / "endsIn"
|
||||
|
||||
def $equalsIgnoreCase(right: Expression[String]) = boolean(Ops.EQ_IGNORE_CASE, expr, right); // XXX "isIgnoreCase" / "eqIgnoreCase"
|
||||
def equalsIgnoreCase(right: Expression[String]) = boolean(Ops.EQ_IGNORE_CASE, this, right); // XXX "isIgnoreCase" / "eqIgnoreCase"
|
||||
|
||||
def $equalsIgnoreCase(right: String): BooleanExpression = $equalsIgnoreCase(resolve(right)); // XXX "isIgnoreCase" / "eqIgnoreCase"
|
||||
def equalsIgnoreCase(right: String): BooleanExpression = equalsIgnoreCase(resolve(right)); // XXX "isIgnoreCase" / "eqIgnoreCase"
|
||||
|
||||
def $isEmpty() = boolean(Ops.STRING_IS_EMPTY, expr); // XXX "empty"
|
||||
def isEmpty() = boolean(Ops.STRING_IS_EMPTY, this); // XXX "empty"
|
||||
|
||||
def $length() = number[Integer](classOf[Integer], Ops.STRING_LENGTH, expr); // XXX "size" (RichString problem?) / "len"
|
||||
def length() = number[Integer](classOf[Integer], Ops.STRING_LENGTH, this); // XXX "size" (RichString problem?) / "len"
|
||||
|
||||
def $startsWith(right: Expression[String]) = boolean(Ops.STARTS_WITH, expr, right); // XXX "beginsWith"
|
||||
def startsWith(right: Expression[String]) = boolean(Ops.STARTS_WITH, this, right); // XXX "beginsWith"
|
||||
|
||||
def $startsWith(right: String): BooleanExpression = $startsWith(resolve(right)); // XXX "beginsWith"
|
||||
def startsWith(right: String): BooleanExpression = startsWith(resolve(right)); // XXX "beginsWith"
|
||||
|
||||
def $substring(right: Int) = string(Ops.SUBSTR_1ARG, expr, resolve(right)); // XXX "substr" / "subString" / "sub"
|
||||
def substring(right: Int) = string(Ops.SUBSTR_1ARG, this, resolve(right)); // XXX "substr" / "subString" / "sub"
|
||||
|
||||
def $substring(right: Int, arg1: Int) = string(Ops.SUBSTR_2ARGS, expr, resolve(right), resolve(arg1)); // XXX "substr" / "subString" / "sub"
|
||||
def substring(right: Int, arg1: Int) = string(Ops.SUBSTR_2ARGS, this, resolve(right), resolve(arg1)); // XXX "substr" / "subString" / "sub"
|
||||
|
||||
def $toLowerCase() = string(Ops.LOWER, expr); // XXX "lower"
|
||||
def toLowerCase() = string(Ops.LOWER, this); // XXX "lower"
|
||||
|
||||
def $toUpperCase() = string(Ops.UPPER, expr); // XXX "upper"
|
||||
def toUpperCase() = string(Ops.UPPER, this); // XXX "upper"
|
||||
|
||||
def $trim() = string(Ops.TRIM, expr); // XXX ???
|
||||
def trim() = string(Ops.TRIM, this); // XXX ???
|
||||
|
||||
def $containsIgnoreCase(right: Expression[String]) = boolean(Ops.STRING_CONTAINS_IC, expr, right); // XXX "hasIgnoreCase"
|
||||
def containsIgnoreCase(right: Expression[String]) = boolean(Ops.STRING_CONTAINS_IC, this, right); // XXX "hasIgnoreCase"
|
||||
|
||||
def $containsIgnoreCase(right: String): BooleanExpression = $containsIgnoreCase(resolve(right)); // ...
|
||||
def containsIgnoreCase(right: String): BooleanExpression = containsIgnoreCase(resolve(right)); // ...
|
||||
|
||||
def $endsWithIgnoreCase(right: Expression[String]) = boolean(Ops.ENDS_WITH_IC, expr, right);
|
||||
def endsWithIgnoreCase(right: Expression[String]) = boolean(Ops.ENDS_WITH_IC, this, right);
|
||||
|
||||
def $endsWithIgnoreCase(right: String): BooleanExpression = $endsWithIgnoreCase(resolve(right));
|
||||
def endsWithIgnoreCase(right: String): BooleanExpression = endsWithIgnoreCase(resolve(right));
|
||||
|
||||
def $isNotEmpty() = $isEmpty().not;
|
||||
def isNotEmpty() = isEmpty().not;
|
||||
|
||||
def $startsWithIgnoreCase(right: Expression[String]) = boolean(Ops.STARTS_WITH_IC, expr, right);
|
||||
def startsWithIgnoreCase(right: Expression[String]) = boolean(Ops.STARTS_WITH_IC, this, right);
|
||||
|
||||
def $startsWithIgnoreCase(right: String): BooleanExpression = $startsWithIgnoreCase(resolve(right));
|
||||
def startsWithIgnoreCase(right: String): BooleanExpression = startsWithIgnoreCase(resolve(right));
|
||||
|
||||
override def $as(right: Path[String]) = string(ALIAS.asInstanceOf[Operator[String]], expr, right);
|
||||
override def as(right: Path[String]) = string(ALIAS.asInstanceOf[Operator[String]], this, right);
|
||||
|
||||
override def $as(alias: String): StringExpression = $as(new PathImpl[String](getType, alias));
|
||||
override def as(alias: String): StringExpression = as(new PathImpl[String](getType, alias));
|
||||
|
||||
|
||||
}
|
||||
|
||||
trait TemporalExpression[T <: Comparable[_]] extends ComparableExpression[T] {
|
||||
|
||||
def $after(right: T) = $gt(right);
|
||||
def after(right: T) = gt(right);
|
||||
|
||||
def $after(right: Expression[T]) = $gt(right);
|
||||
def after(right: Expression[T]) = gt(right);
|
||||
|
||||
def $before(right: T) = $lt(right);
|
||||
def before(right: T) = lt(right);
|
||||
|
||||
def $before(right: Expression[T]) = $lt(right);
|
||||
def before(right: Expression[T]) = lt(right);
|
||||
|
||||
}
|
||||
|
||||
trait TimeExpression[T <: Comparable[_]] extends TemporalExpression[T] {
|
||||
|
||||
def $hour() = number(classOf[Integer], DateTimeOps.HOUR, expr);
|
||||
def hour() = number(classOf[Integer], DateTimeOps.HOUR, this);
|
||||
|
||||
def $minute() = number(classOf[Integer], DateTimeOps.MINUTE, expr);
|
||||
def minute() = number(classOf[Integer], DateTimeOps.MINUTE, this);
|
||||
|
||||
def $second() = number(classOf[Integer], DateTimeOps.SECOND, expr);
|
||||
def second() = number(classOf[Integer], DateTimeOps.SECOND, this);
|
||||
|
||||
def $milliSecond() = number(classOf[Integer], DateTimeOps.MILLISECOND, expr);
|
||||
def milliSecond() = number(classOf[Integer], DateTimeOps.MILLISECOND, this);
|
||||
|
||||
override def $as(right: Path[T]) = time(getType, ALIAS.asInstanceOf[Operator[T]], expr, right);
|
||||
override def as(right: Path[T]) = time(getType, ALIAS.asInstanceOf[Operator[T]], this, right);
|
||||
|
||||
override def $as(alias: String): TimeExpression[T] = $as(new PathImpl[T](getType, alias));
|
||||
override def as(alias: String): TimeExpression[T] = as(new PathImpl[T](getType, alias));
|
||||
|
||||
}
|
||||
|
||||
trait DateTimeExpression[T <: Comparable[_]] extends TemporalExpression[T] {
|
||||
|
||||
def $min() = dateTime(getType, AggOps.MIN_AGG, expr);
|
||||
def min() = dateTime(getType, AggOps.MIN_AGG, this);
|
||||
|
||||
def $max() = dateTime(getType, AggOps.MAX_AGG, expr);
|
||||
def max() = dateTime(getType, AggOps.MAX_AGG, this);
|
||||
|
||||
def $dayOfMonth() = number(classOf[Integer], DateTimeOps.DAY_OF_MONTH, expr);
|
||||
def dayOfMonth() = number(classOf[Integer], DateTimeOps.DAY_OF_MONTH, this);
|
||||
|
||||
def $dayOfWeek() = number(classOf[Integer], DateTimeOps.DAY_OF_WEEK, expr);
|
||||
def dayOfWeek() = number(classOf[Integer], DateTimeOps.DAY_OF_WEEK, this);
|
||||
|
||||
def $dayOfYear() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, expr);
|
||||
def dayOfYear() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this);
|
||||
|
||||
def $week() = number(classOf[Integer], DateTimeOps.WEEK, expr);
|
||||
def week() = number(classOf[Integer], DateTimeOps.WEEK, this);
|
||||
|
||||
def $month() = number(classOf[Integer], DateTimeOps.MONTH, expr);
|
||||
def month() = number(classOf[Integer], DateTimeOps.MONTH, this);
|
||||
|
||||
def $year() = number(classOf[Integer], DateTimeOps.YEAR, expr);
|
||||
def year() = number(classOf[Integer], DateTimeOps.YEAR, this);
|
||||
|
||||
def $yearMonth() = number(classOf[Integer], DateTimeOps.YEAR_MONTH, expr);
|
||||
def yearMonth() = number(classOf[Integer], DateTimeOps.YEAR_MONTH, this);
|
||||
|
||||
def $hour() = number(classOf[Integer], DateTimeOps.HOUR, expr);
|
||||
def hour() = number(classOf[Integer], DateTimeOps.HOUR, this);
|
||||
|
||||
def $minute() = number(classOf[Integer], DateTimeOps.MINUTE, expr);
|
||||
def minute() = number(classOf[Integer], DateTimeOps.MINUTE, this);
|
||||
|
||||
def $second() = number(classOf[Integer], DateTimeOps.SECOND, expr);
|
||||
def second() = number(classOf[Integer], DateTimeOps.SECOND, this);
|
||||
|
||||
def $milliSecond() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, expr);
|
||||
def milliSecond() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this);
|
||||
|
||||
override def $as(right: Path[T]) = dateTime(getType, ALIAS.asInstanceOf[Operator[T]], expr, right);
|
||||
override def as(right: Path[T]) = dateTime(getType, ALIAS.asInstanceOf[Operator[T]], this, right);
|
||||
|
||||
override def $as(alias: String): DateTimeExpression[T] = $as(new PathImpl[T](getType, alias));
|
||||
override def as(alias: String): DateTimeExpression[T] = as(new PathImpl[T](getType, alias));
|
||||
|
||||
}
|
||||
|
||||
trait DateExpression[T <: Comparable[_]] extends TemporalExpression[T] {
|
||||
|
||||
def $min() = date(getType, AggOps.MIN_AGG, expr);
|
||||
def min() = date(getType, AggOps.MIN_AGG, this);
|
||||
|
||||
def $max() = date(getType, AggOps.MAX_AGG, expr);
|
||||
def max() = date(getType, AggOps.MAX_AGG, this);
|
||||
|
||||
def $dayOfMonth() = number(classOf[Integer], DateTimeOps.DAY_OF_MONTH, expr);
|
||||
def dayOfMonth() = number(classOf[Integer], DateTimeOps.DAY_OF_MONTH, this);
|
||||
|
||||
def $dayOfWeek() = number(classOf[Integer], DateTimeOps.DAY_OF_WEEK, expr);
|
||||
def dayOfWeek() = number(classOf[Integer], DateTimeOps.DAY_OF_WEEK, this);
|
||||
|
||||
def $dayOfYear() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, expr);
|
||||
def dayOfYear() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this);
|
||||
|
||||
def $week() = number(classOf[Integer], DateTimeOps.WEEK, expr);
|
||||
def week() = number(classOf[Integer], DateTimeOps.WEEK, this);
|
||||
|
||||
def $month() = number(classOf[Integer], DateTimeOps.MONTH, expr);
|
||||
def month() = number(classOf[Integer], DateTimeOps.MONTH, this);
|
||||
|
||||
def $year() = number(classOf[Integer], DateTimeOps.YEAR, expr);
|
||||
def year() = number(classOf[Integer], DateTimeOps.YEAR, this);
|
||||
|
||||
def $yearMonth() = number(classOf[Integer], DateTimeOps.YEAR_MONTH, expr);
|
||||
def yearMonth() = number(classOf[Integer], DateTimeOps.YEAR_MONTH, this);
|
||||
|
||||
override def $as(right: Path[T]) = date(getType, ALIAS.asInstanceOf[Operator[T]], expr, right);
|
||||
override def as(right: Path[T]) = date(getType, ALIAS.asInstanceOf[Operator[T]], this, right);
|
||||
|
||||
override def $as(alias: String): DateExpression[T] = $as(new PathImpl[T](getType, alias));
|
||||
override def as(alias: String): DateExpression[T] = as(new PathImpl[T](getType, alias));
|
||||
|
||||
}
|
||||
|
||||
trait EnumExpression[T <: Enum[T]] extends ComparableExpression[T] {
|
||||
|
||||
def $ordinal() = number(classOf[Integer], Ops.ORDINAL, expr);
|
||||
def ordinal() = number(classOf[Integer], Ops.ORDINAL, this);
|
||||
|
||||
override def $as(right: Path[T]) = enum(getType.asInstanceOf[Class[T]], ALIAS.asInstanceOf[Operator[T]], expr, right);
|
||||
override def as(right: Path[T]) = enum(getType.asInstanceOf[Class[T]], ALIAS.asInstanceOf[Operator[T]], this, right);
|
||||
|
||||
override def $as(alias: String): EnumExpression[T] = $as(new PathImpl[T](getType, alias));
|
||||
override def as(alias: String): EnumExpression[T] = as(new PathImpl[T](getType, alias));
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -36,54 +36,45 @@ object Operations {
|
||||
|
||||
class SimpleOperation[T](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]*)
|
||||
extends OperationImpl[T](t, operator, args: _*) with SimpleExpression[T] {
|
||||
|
||||
def expr = this
|
||||
|
||||
}
|
||||
|
||||
class ComparableOperation[T <: Comparable[_]](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]*)
|
||||
extends OperationImpl[T](t, operator, args: _*) with ComparableExpression[T] {
|
||||
|
||||
def expr = this
|
||||
|
||||
}
|
||||
|
||||
class NumberOperation[T <: Number with Comparable[T]](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]*)
|
||||
extends OperationImpl[T](t, operator, args: _*) with NumberExpression[T] {
|
||||
|
||||
def expr = this
|
||||
|
||||
}
|
||||
|
||||
class BooleanOperation(operator: Operator[_ >: java.lang.Boolean], args: Expression[_]*)
|
||||
extends OperationImpl[java.lang.Boolean](classOf[java.lang.Boolean], operator, args: _*) with BooleanExpression {
|
||||
|
||||
def expr = this
|
||||
|
||||
}
|
||||
|
||||
class StringOperation(operator: Operator[_ >: String], args: Expression[_]*)
|
||||
extends OperationImpl[String](classOf[String], operator, args: _*) with StringExpression {
|
||||
|
||||
def expr = this
|
||||
|
||||
}
|
||||
|
||||
class DateOperation[T <: Comparable[_]](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]*)
|
||||
extends OperationImpl[T](t, operator, args: _*) with DateExpression[T] {
|
||||
|
||||
def expr = this
|
||||
|
||||
}
|
||||
|
||||
class DateTimeOperation[T <: Comparable[_]](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]*)
|
||||
extends OperationImpl[T](t, operator, args: _*) with DateTimeExpression[T] {
|
||||
|
||||
def expr = this
|
||||
|
||||
}
|
||||
|
||||
class TimeOperation[T <: Comparable[_]](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]*)
|
||||
extends OperationImpl[T](t, operator, args: _*) with TimeExpression[T] {
|
||||
|
||||
def expr = this
|
||||
|
||||
}
|
||||
|
||||
class EnumOperation[T <: Enum[T]](t: Class[T], operator: Operator[_ >: T], args: Expression[_]*)
|
||||
extends OperationImpl[T](t, operator, args: _*) with EnumExpression[T] {
|
||||
|
||||
def expr = this
|
||||
|
||||
}
|
||||
|
||||
@ -45,7 +45,7 @@ class SimplePath[T](t: Class[_ <: T], md: PathMetadata[_])
|
||||
|
||||
def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
}
|
||||
|
||||
@ -54,7 +54,7 @@ class ArrayPath[T <: Array[_]](t: Class[T], md: PathMetadata[_])
|
||||
|
||||
def this(t: Class[T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
}
|
||||
|
||||
@ -63,7 +63,7 @@ class EntityPathImpl[T](t: Class[_ <: T], md: PathMetadata[_])
|
||||
|
||||
def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
}
|
||||
|
||||
class CollectionPath[T](t: Class[_ <: T], md: PathMetadata[_])
|
||||
@ -71,7 +71,7 @@ class CollectionPath[T](t: Class[_ <: T], md: PathMetadata[_])
|
||||
|
||||
def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
def getParameter(i: Int) = t;
|
||||
|
||||
@ -82,7 +82,7 @@ class SetPath[T](t: Class[_ <: T], md: PathMetadata[_])
|
||||
|
||||
def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
def getParameter(i: Int) = t;
|
||||
|
||||
@ -93,7 +93,7 @@ class ListPath[T](t: Class[_ <: T], md: PathMetadata[_])
|
||||
|
||||
def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
def getParameter(i: Int) = t;
|
||||
|
||||
@ -104,7 +104,7 @@ class MapPath[K, V](k: Class[_ <: K], v: Class[_ <: V], md: PathMetadata[_])
|
||||
|
||||
def this(k: Class[_ <: K], v: Class[_ <: V], variable: String) = this(k, v, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
def getParameter(i: Int): Class[_] = { if (i == 0) k else v }
|
||||
|
||||
@ -115,7 +115,7 @@ class ComparablePath[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_])
|
||||
|
||||
def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
}
|
||||
|
||||
class NumberPath[T <: Number with Comparable[T]](t: Class[_ <: T], md: PathMetadata[_])
|
||||
@ -123,7 +123,7 @@ class NumberPath[T <: Number with Comparable[T]](t: Class[_ <: T], md: PathMetad
|
||||
|
||||
def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
}
|
||||
|
||||
class BooleanPath(md: PathMetadata[_])
|
||||
@ -131,7 +131,7 @@ class BooleanPath(md: PathMetadata[_])
|
||||
|
||||
def this(variable: String) = this(forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
}
|
||||
|
||||
@ -140,7 +140,7 @@ class StringPath(md: PathMetadata[_])
|
||||
|
||||
def this(variable: String) = this(forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
}
|
||||
|
||||
@ -149,7 +149,7 @@ class DatePath[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_])
|
||||
|
||||
def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
}
|
||||
|
||||
@ -158,7 +158,7 @@ class DateTimePath[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_])
|
||||
|
||||
def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
}
|
||||
|
||||
@ -167,7 +167,7 @@ class TimePath[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_])
|
||||
|
||||
def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
}
|
||||
|
||||
@ -176,6 +176,6 @@ class EnumPath[T <: Enum[T]](t: Class[_ <: T], md: PathMetadata[_])
|
||||
|
||||
def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable));
|
||||
|
||||
def expr = this
|
||||
def ~ = this
|
||||
|
||||
}
|
||||
|
||||
@ -6,17 +6,18 @@ import com.mysema.query.sql.SQLSubQuery
|
||||
import com.mysema.query.types._
|
||||
import com.mysema.query.types.path._
|
||||
import org.junit.Test
|
||||
import org.junit.Assert
|
||||
|
||||
class AliasTest {
|
||||
|
||||
val person = alias(classOf[Person])
|
||||
|
||||
def assertEquals(expected: String, actual: Expression[_]) {
|
||||
org.junit.Assert.assertEquals(expected, actual.toString);
|
||||
}
|
||||
Assert.assertEquals(expected, actual.toString);
|
||||
}
|
||||
|
||||
def assertEquals(expected: String, actual: OrderSpecifier[_]) {
|
||||
org.junit.Assert.assertEquals(expected, actual.toString);
|
||||
Assert.assertEquals(expected, actual.toString);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -39,7 +40,7 @@ class AliasTest {
|
||||
|
||||
@Test
|
||||
def String_Like {
|
||||
assertEquals("person.firstName like Ben", person.firstName $like "Ben");
|
||||
assertEquals("person.firstName like Ben", person.firstName like "Ben");
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -49,78 +50,85 @@ class AliasTest {
|
||||
|
||||
@Test
|
||||
def String_Append {
|
||||
assertEquals("person.firstName + x", person.firstName $append "x");
|
||||
assertEquals("person.firstName + x", person.firstName append "x");
|
||||
}
|
||||
|
||||
@Test
|
||||
def String_Append2 {
|
||||
assertEquals("person.firstName + + person.lastName", person.firstName $append " " $append person.lastName);
|
||||
assertEquals("person.firstName + + person.lastName", person.firstName append " " append person.lastName);
|
||||
}
|
||||
|
||||
@Test
|
||||
def String_And {
|
||||
val andClause = (person.firstName $like "An%") $and (person.firstName $like "Be%");
|
||||
val andClause = (person.firstName like "An%") and (person.firstName like "Be%");
|
||||
assertEquals("person.firstName like An% && person.firstName like Be%", andClause);
|
||||
}
|
||||
|
||||
@Test
|
||||
def String_Or {
|
||||
val orClause = (person.firstName $like "An%") $or (person.firstName $like "Be%");
|
||||
val orClause = (person.firstName like "An%") or (person.firstName like "Be%");
|
||||
assertEquals("person.firstName like An% || person.firstName like Be%", orClause);
|
||||
}
|
||||
|
||||
@Test
|
||||
def String_Not {
|
||||
assertEquals("!person.firstName like An%", (person.firstName $like "An%") not);
|
||||
|
||||
assertEquals("!person.firstName like An%", not(person.firstName $like "An%"));
|
||||
assertEquals("!person.firstName like An%", (person.firstName like "An%") not);
|
||||
assertEquals("!person.firstName like An%", not(person.firstName like "An%"));
|
||||
}
|
||||
|
||||
@Test
|
||||
def String_Trim {
|
||||
assertEquals("trim(person.firstName)", person.firstName $trim);
|
||||
assertEquals("trim(person.firstName)", person.firstName trim);
|
||||
}
|
||||
|
||||
@Test
|
||||
def String_Is_Empty {
|
||||
assertEquals("empty(person.firstName)", person.firstName $isEmpty);
|
||||
val predicate: Predicate = person.firstName isEmpty();
|
||||
assertEquals("empty(person.firstName)", predicate);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Number_Comparison {
|
||||
assertEquals("person.scalaInt < 5", person.scalaInt $lt 5);
|
||||
assertEquals("person.javaInt < 5", person.javaInt $lt 5);
|
||||
assertEquals("person.javaInt > 5", person.javaInt $gt 5);
|
||||
assertEquals("person.javaInt <= 5", person.javaInt $loe 5);
|
||||
assertEquals("person.javaInt >= 5", person.javaInt $goe 5);
|
||||
val predicate: Predicate = person.scalaInt lt 5;
|
||||
assertEquals("person.scalaInt < 5", predicate);
|
||||
assertEquals("person.javaInt < 5", person.javaInt lt 5);
|
||||
assertEquals("person.javaInt > 5", person.javaInt gt 5);
|
||||
assertEquals("person.javaInt <= 5", person.javaInt loe 5);
|
||||
assertEquals("person.javaInt >= 5", person.javaInt goe 5);
|
||||
assertEquals("person.javaInt = 5", person.javaInt $eq 5);
|
||||
assertEquals("person.javaInt != 5", person.javaInt $ne 5);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Number_Comparison2{
|
||||
val predicate: Predicate = person.javaInt < 5
|
||||
assertEquals("person.javaInt < 5", predicate);
|
||||
}
|
||||
|
||||
def Number_Comparison2 {
|
||||
val predicate: Predicate = person.scalaInt < 5;
|
||||
assertEquals("person.scalaInt < 5", predicate);
|
||||
assertEquals("person.javaInt < 5", person.javaInt < 5);
|
||||
assertEquals("person.javaInt > 5", person.javaInt > 5);
|
||||
assertEquals("person.javaInt <= 5", person.javaInt <= 5);
|
||||
assertEquals("person.javaInt >= 5", person.javaInt >= 5);
|
||||
assertEquals("person.javaInt = 5", person.javaInt $eq 5);
|
||||
assertEquals("person.javaInt != 5", person.javaInt $ne 5);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Number_Between {
|
||||
assertEquals("person.scalaInt between 2 and 3", person.scalaInt $between (2, 3));
|
||||
assertEquals("person.javaInt between 2 and 3", person.javaInt $between (2, 3));
|
||||
assertEquals("person.scalaInt between 2 and 3", person.scalaInt between (2, 3));
|
||||
assertEquals("person.javaInt between 2 and 3", person.javaInt between (2, 3));
|
||||
}
|
||||
|
||||
@Test
|
||||
def Number_Arithmetic {
|
||||
assertEquals("person.scalaInt + 3", person.scalaInt $add 3);
|
||||
assertEquals("person.scalaInt - 3", person.scalaInt $subtract 3);
|
||||
assertEquals("person.scalaInt / 3", person.scalaInt $divide 3);
|
||||
assertEquals("person.scalaInt * 3", person.scalaInt $multiply 3);
|
||||
assertEquals("person.scalaInt * -1", person.scalaInt $negate);
|
||||
assertEquals("person.scalaInt % 4", person.scalaInt $mod 4);
|
||||
assertEquals("round(person.scalaInt)", person.scalaInt $round);
|
||||
assertEquals("floor(person.scalaInt)", person.scalaInt $floor);
|
||||
assertEquals("ceil(person.scalaInt)", person.scalaInt $ceil);
|
||||
assertEquals("sqrt(person.scalaInt)", person.scalaInt $sqrt);
|
||||
assertEquals("person.scalaInt + 3", person.scalaInt add 3);
|
||||
assertEquals("person.scalaInt - 3", person.scalaInt subtract 3);
|
||||
assertEquals("person.scalaInt / 3", person.scalaInt divide 3);
|
||||
assertEquals("person.scalaInt * 3", person.scalaInt multiply 3);
|
||||
assertEquals("person.scalaInt * -1", person.scalaInt negate);
|
||||
assertEquals("person.scalaInt % 4", person.scalaInt mod 4);
|
||||
assertEquals("round(person.scalaInt)", person.scalaInt round);
|
||||
assertEquals("floor(person.scalaInt)", person.scalaInt floor);
|
||||
assertEquals("ceil(person.scalaInt)", person.scalaInt ceil);
|
||||
assertEquals("sqrt(person.scalaInt)", person.scalaInt sqrt);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -131,92 +139,114 @@ class AliasTest {
|
||||
|
||||
@Test
|
||||
def Java_Collections_Size {
|
||||
assertEquals("size(person.javaCollection)", person.javaCollection $size);
|
||||
assertEquals("size(person.javaSet)", person.javaSet $size);
|
||||
assertEquals("size(person.javaList)", person.javaList $size);
|
||||
assertEquals("size(person.javaMap)", person.javaMap $size);
|
||||
assertEquals("size(person.javaCollection)", person.javaCollection size);
|
||||
assertEquals("size(person.javaSet)", person.javaSet size);
|
||||
assertEquals("size(person.javaList)", person.javaList size);
|
||||
assertEquals("size(person.javaMap)", person.javaMap size);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Java_Collections_Is_Empty {
|
||||
assertEquals("empty(person.javaCollection)", person.javaCollection $isEmpty);
|
||||
assertEquals("empty(person.javaSet)", person.javaSet $isEmpty);
|
||||
assertEquals("empty(person.javaList)", person.javaList $isEmpty);
|
||||
assertEquals("empty(person.javaMap)", person.javaMap $isEmpty);
|
||||
assertEquals("empty(person.javaCollection)", person.javaCollection isEmpty);
|
||||
assertEquals("empty(person.javaSet)", person.javaSet isEmpty);
|
||||
assertEquals("empty(person.javaList)", person.javaList isEmpty);
|
||||
assertEquals("empty(person.javaMap)", person.javaMap isEmpty);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Java_Collections_Get {
|
||||
assertEquals("person.javaList.get(0) is not null", person.javaList.get(0) $isNotNull);
|
||||
assertEquals("person.javaMap.get(xxx) is null", person.javaMap.get("xxx") $isNull);
|
||||
assertEquals("person.javaList.get(0) is not null", person.javaList.get(0) isNotNull);
|
||||
assertEquals("person.javaMap.get(xxx) is null", person.javaMap.get("xxx") isNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Java_Collections_Get_And_Starts_With {
|
||||
assertEquals("startsWith(person.javaMap.get(xxx),X)", person.javaMap.get("xxx") $startsWith "X");
|
||||
assertEquals("startsWith(person.javaMap.get(xxx),X)", person.javaMap.get("xxx") startsWith "X");
|
||||
}
|
||||
|
||||
@Test
|
||||
def Scala_Collections_Size {
|
||||
assertEquals("size(person.scalaList)", person.scalaList $size);
|
||||
assertEquals("size(person.scalaMap)", person.scalaMap $size);
|
||||
assertEquals("size(person.scalaList)", person.scalaList size);
|
||||
assertEquals("size(person.scalaMap)", person.scalaMap size);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Scala_Collections_Is_Empty {
|
||||
assertEquals("empty(person.scalaList)", person.scalaList $isEmpty);
|
||||
assertEquals("empty(person.scalaMap)", person.scalaMap $isEmpty);
|
||||
assertEquals("empty(person.scalaList)", person.scalaList isEmpty);
|
||||
assertEquals("empty(person.scalaMap)", person.scalaMap isEmpty);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Scala_Collections_Get {
|
||||
assertEquals("person.scalaList.get(0) is not null", person.scalaList(0) $isNotNull);
|
||||
assertEquals("person.scalaList.get(0) is not null", person.scalaList(0) $isNotNull);
|
||||
assertEquals("person.scalaMap.get(xxx) is null", person.scalaMap("xxx") $isNull);
|
||||
assertEquals("person.scalaList.get(0) is not null", person.scalaList(0) isNotNull);
|
||||
assertEquals("person.scalaList.get(0) is not null", person.scalaList(0) isNotNull);
|
||||
assertEquals("person.scalaMap.get(xxx) is null", person.scalaMap("xxx") isNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Scala_Collections_Contains {
|
||||
assertEquals("X in person.scalaList", person.scalaList $contains "X");
|
||||
assertEquals("X in person.javaList", person.javaList $contains "X");
|
||||
assertEquals("X in person.scalaList", person.scalaList contains "X");
|
||||
assertEquals("X in person.javaList", person.javaList contains "X");
|
||||
}
|
||||
|
||||
@Test
|
||||
def Scala_Collections_Get_And_Starts_With {
|
||||
assertEquals("startsWith(person.scalaMap.get(xxx),X)", person.scalaMap("xxx") $startsWith "X");
|
||||
assertEquals("startsWith(person.scalaMap.get(xxx),X)", person.scalaMap("xxx") startsWith "X");
|
||||
}
|
||||
|
||||
@Test
|
||||
def Array_Size {
|
||||
assertEquals("size(person.array)", person.array $size ());
|
||||
val num: NumberExpression[Integer] = person.array size();
|
||||
assertEquals("size(person.array)", num);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Complex_Starts_With_And_Less_Than_And_Is_Null() {
|
||||
val expr = ((person.firstName $startsWith person.lastName)
|
||||
$and (person.javaInt $lt person.scalaInt)
|
||||
$or (person.javaDouble $isNull));
|
||||
assertEquals("startsWith(person.firstName,person.lastName) " +
|
||||
val expr: Predicate = (person.firstName startsWith person.lastName) and (person.javaInt lt person.scalaInt) or (person.javaDouble isNull);
|
||||
assertEquals("startsWith(person.firstName,person.lastName) " +
|
||||
"&& person.javaInt < person.scalaInt " +
|
||||
"|| person.javaDouble is null", expr);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Lt_and_Gt() {
|
||||
val expr: Predicate = (person.javaInt < 5) and (person.scalaInt > 7);
|
||||
assertEquals("person.javaInt < 5 and person.scalaInt > 7", expr);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Gt_and_Lt() {
|
||||
val expr: Predicate = (person.javaInt > 5) and (person.scalaInt < 7);
|
||||
assertEquals("person.javaInt > 5 and person.scalaInt < 7", expr);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Lt_or_Gt() {
|
||||
val expr: Predicate = (person.javaInt < 5) or (person.scalaInt > 7);
|
||||
assertEquals("person.javaInt < 5 or person.scalaInt > 7", expr);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Gt_or_Lt() {
|
||||
val expr: Predicate = (person.javaInt > 5) or (person.scalaInt < 7);
|
||||
assertEquals("person.javaInt > 5 or person.scalaInt < 7", expr);
|
||||
}
|
||||
|
||||
@Test
|
||||
def Starts_with() {
|
||||
assertEquals("startsWith(person.firstName,amin)", person.firstName $startsWith "amin");
|
||||
assertEquals("startsWith(person.firstName,amin)", person.firstName startsWith "amin");
|
||||
}
|
||||
|
||||
@Test
|
||||
def Ends_with() {
|
||||
assertEquals("endsWith(person.firstName,amin)", person.firstName $endsWith "amin");
|
||||
assertEquals("endsWith(person.firstName,amin)", person.firstName endsWith "amin");
|
||||
}
|
||||
|
||||
@Test
|
||||
def Prefix(){
|
||||
assertEquals("count(person)", count(person));
|
||||
// FIXME
|
||||
// assertEquals("min(person.javaInt)", min(person.javaInt));
|
||||
// assertEquals("min(person.scalaInt)", min(person.scalaInt));
|
||||
assertEquals("count(person)", count(person));
|
||||
assertEquals("min(person.javaInt)", min(person.javaInt));
|
||||
assertEquals("min(person.scalaInt)", min(person.scalaInt));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -70,7 +70,7 @@ class JPAIntegrationTest {
|
||||
assertEquals(1, query from company list company size);
|
||||
|
||||
assertEquals("Bob", query from user where (user.userName $eq "Bob") uniqueResult user.userName);
|
||||
assertEquals("Bob", query from user where (user.userName $like "Bo%") uniqueResult user.userName);
|
||||
assertEquals("Bob", query from user where (user.userName like "Bo%") uniqueResult user.userName);
|
||||
assertEquals("Ann", query from user where (user.department.name $eq "Sales") uniqueResult user.userName);
|
||||
}
|
||||
|
||||
|
||||
@ -13,7 +13,7 @@ class JPAQueryTest {
|
||||
|
||||
@Test
|
||||
def OneLiner() {
|
||||
query from (person) where (person.firstName $like "Rob%") unique (person);
|
||||
query from (person) where (person.firstName like "Rob%") unique (person);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -36,8 +36,10 @@ class JPAQueryTest {
|
||||
|
||||
@Test
|
||||
def Filters() {
|
||||
query from (person) where (person.firstName $isEmpty) count;
|
||||
query from (person) where (person.firstName $isEmpty, person.lastName $isNotNull) list (person);
|
||||
query from (person) where (person.firstName isEmpty()) count;
|
||||
query from (person) where (person.firstName isEmpty(), person.lastName isNotNull()) list (person);
|
||||
query from (person) where (person.firstName startsWith "X") count;
|
||||
query from (person) where (person.javaInt < 5) count
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -48,16 +50,16 @@ class JPAQueryTest {
|
||||
@Test
|
||||
def Various() {
|
||||
// list
|
||||
query from (person) where (person.firstName $like "Rob%") list (person);
|
||||
query from (person) where (person.firstName like "Rob%") list (person);
|
||||
// unique result
|
||||
query from (person) where (person.firstName $like "Rob%") unique (person);
|
||||
query from (person) where (person.firstName like "Rob%") unique (person);
|
||||
// long where
|
||||
query from (person) where (person.firstName $like "Rob%", person.lastName $like "An%") list (person)
|
||||
query from (person) where (person.firstName like "Rob%", person.lastName like "An%") list (person)
|
||||
}
|
||||
|
||||
@Test
|
||||
def Complex() {
|
||||
query from person where (person.firstName $like "An%") $and (person.lastName $isNotNull) list person;
|
||||
query from person where ((person.firstName like "An%") and (person.lastName isNotNull)) list person;
|
||||
}
|
||||
|
||||
def query() = new JPQLSubQuery()
|
||||
|
||||
@ -23,7 +23,7 @@ class ProjectionTest {
|
||||
@Test
|
||||
def QTuple(){
|
||||
val tuple = new QTuple(person.firstName, person.lastName);
|
||||
assertEquals(asList(person.firstName.expr, person.lastName.expr), tuple.getArgs);
|
||||
assertEquals(asList(person.firstName.~, person.lastName.~), tuple.getArgs);
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user