diff --git a/querydsl-scala/readme.txt b/querydsl-scala/readme.txt index 2575ca2a3..784df91bc 100644 --- a/querydsl-scala/readme.txt +++ b/querydsl-scala/readme.txt @@ -13,4 +13,6 @@ $ : (domainType.firstName $like "An%") $and (domainType.firstName $like TODO : +* Resolve paths in operation handling as well + * Hibernate test \ No newline at end of file diff --git a/querydsl-scala/src/main/scala/com/mysema/query/scala/Conversions.scala b/querydsl-scala/src/main/scala/com/mysema/query/scala/Conversions.scala index aea1497bc..f3ffe7e79 100644 --- a/querydsl-scala/src/main/scala/com/mysema/query/scala/Conversions.scala +++ b/querydsl-scala/src/main/scala/com/mysema/query/scala/Conversions.scala @@ -19,7 +19,7 @@ object Conversions { val aliasFactory = new AliasFactory(new PathFactoryImpl()); - def not(b: BooleanExpression) = b._not() + def not(b: BooleanExpression) = b.not; def alias[T](cl: Class[T]): T = alias(cl, StringUtils.uncapitalize(cl.getSimpleName)); @@ -29,6 +29,8 @@ object Conversions { // implicit conversions + implicit def arrayPath[T <: Array[_]](a: T): ArrayPath[T] = aliasFactory.getCurrentAndReset(); + implicit def booleanPath(b: java.lang.Boolean): BooleanPath = aliasFactory.getCurrentAndReset(); implicit def stringPath(s: String): StringPath = aliasFactory.getCurrentAndReset(); @@ -80,8 +82,8 @@ object Conversions { }else { arg match { case x:EntityPathImpl[_] => x; - case x:ManagedObject => x.__mappedPath.asInstanceOf[EntityPathImpl[_]]; - case _ => null; + case x:ManagedObject => x.__mappedPath.asInstanceOf[EntityPathImpl[_]]; + case _ => null; } } } diff --git a/querydsl-scala/src/main/scala/com/mysema/query/scala/Expressions.scala b/querydsl-scala/src/main/scala/com/mysema/query/scala/Expressions.scala index 5defa537a..496aa550d 100644 --- a/querydsl-scala/src/main/scala/com/mysema/query/scala/Expressions.scala +++ b/querydsl-scala/src/main/scala/com/mysema/query/scala/Expressions.scala @@ -26,216 +26,216 @@ object Constants { } trait SimpleExpression[T] extends Expression[T] { + + def $eq(right: T): BooleanExpression = $eq(constant(right)); // XXX "is" - def _count() = number[java.lang.Long](classOf[java.lang.Long], AggOps.COUNT_AGG, this); + def $eq(right: Expression[T]) = boolean(EQ_OBJECT, this, right); // XXX "is" + + def $ne(right: T): BooleanExpression = $ne(constant(right)); // XXX "<>" / "isnt" / "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, this); - def _in(right: Collection[T]) = boolean(IN, this, constant(right)); + def $in(right: Collection[T]) = boolean(IN, this, constant(right)); - def _in(right: T*) : BooleanOperation = _in(asList(right:_*)); + def $in(right: T*) : BooleanOperation = $in(asList(right:_*)); - def _in(right: CollectionExpression[T]) = boolean(IN, this, right); - - def _eq(right: T): BooleanExpression = _eq(constant(right)); // XXX "is" - - def _eq(right: Expression[T]) = boolean(EQ_OBJECT, this, right); // XXX "is" + def $in(right: CollectionExpression[T]) = boolean(IN, this, right); // TODO : get rid of asInstanceOf - def _as(right: Path[T]): SimpleExpression[T] = simple(getType, ALIAS.asInstanceOf[Operator[T]], this, 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 _countDistinct() = number[java.lang.Long](classOf[java.lang.Long], AggOps.COUNT_DISTINCT_AGG, this); + def $countDistinct() = number[java.lang.Long](classOf[java.lang.Long], AggOps.COUNT_DISTINCT_AGG, this); - def _isNotNull() = boolean(IS_NOT_NULL, this); + def $isNotNull() = boolean(IS_NOT_NULL, this); - def _isNull() = boolean(IS_NULL, this); + def $isNull() = boolean(IS_NULL, this); + + def $notIn(right: Collection[T]) = $in(right).not; - def _ne(right: T): BooleanExpression = _ne(constant(right)); // XXX "isnt" / "isNot" - - def _ne(right: Expression[T]) = boolean(NE_OBJECT, this, right); // XXX "isNot" - - def _notIn(right: Collection[T]) = _in(right)._not(); - - def _notIn(right: T*) = _in(right:_*)._not(); - - def _notIn(right: CollectionExpression[T]) = _in(right)._not(); + def $notIn(right: 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, this); + def $size() = number[Integer](classOf[Integer], Ops.ARRAY_SIZE, this); -// def _get(index: Integer) = Paths.simple(getType.getComponentType, forArrayAccess(this, index.intValue)); +// def $get(index: Integer) = Paths.simple(getType.getComponentType, forArrayAccess(this, index.intValue)); } -trait CollectionExpressionBase[T <: Collection[_]] extends SimpleExpression[T] with ParametrizedExpression[T] { +trait CollectionExpressionBase[T <: Collection[C],C] extends SimpleExpression[T] with ParametrizedExpression[T] { - 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: T) = boolean(IN, constant(child), this); + def $contains(child: C) = boolean(IN, constant(child), this); - def _contains(child: Expression[T]) = boolean(IN, child, this); + def $contains(child: Expression[C]) = boolean(IN, child, this); } -trait CollectionExpression[T] extends CollectionExpressionBase[java.util.Collection[T]] { } +trait CollectionExpression[T] extends CollectionExpressionBase[java.util.Collection[T],T] { } -trait SetExpression[T] extends CollectionExpressionBase[java.util.Set[T]] { } +trait SetExpression[T] extends CollectionExpressionBase[java.util.Set[T],T] { } -trait ListExpression[T] extends CollectionExpressionBase[java.util.List[T]] { +trait ListExpression[T] extends CollectionExpressionBase[java.util.List[T],T] { } trait MapExpression[K,V] extends SimpleExpression[java.util.Map[K,V]] with ParametrizedExpression[java.util.Map[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, constant(k)); + def $containsKey(k: K) = boolean(CONTAINS_KEY, this, constant(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, constant(v)); + def $containsValue(v: V) = boolean(CONTAINS_KEY, this, constant(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, this); + def asc = new OrderSpecifier[T](Order.ASC, this); - def _desc = new OrderSpecifier[T](Order.DESC, this); + def desc = new OrderSpecifier[T](Order.DESC, this); } trait ComparableExpression[T <: Comparable[_]] extends ComparableExpressionBase[T] { - def _lt(right: T) : BooleanExpression = _lt(constant(right)); + def $lt(right: T) : BooleanExpression = $lt(constant(right)); - def _lt(right: Expression[T]): BooleanExpression = boolean(BEFORE, this, right); + def $lt(right: Expression[T]): BooleanExpression = boolean(BEFORE, this, right); // TODO : get rid of asInstanceOf - override def _as(right: Path[T]) = comparable(getType, ALIAS.asInstanceOf[Operator[T]], 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)); + override def $as(alias: String): ComparableExpression[T] = $as(new PathImpl[T](getType, alias)); - def _between(left: T, right: T): BooleanExpression = _between(constant(left), constant(right)); + def $between(left: T, right: T): BooleanExpression = $between(constant(left), constant(right)); - def _between(left: Expression[T], right: Expression[T]) = boolean(BETWEEN, this, left, right);; + def $between(left: Expression[T], right: Expression[T]) = boolean(BETWEEN, this, left, right);; - def _notBetween(left: T, right: T): BooleanExpression = _notBetween(constant(left), constant(right)); + def $notBetween(left: T, right: T): BooleanExpression = $notBetween(constant(left), constant(right)); - def _notBetween(left: Expression[T], right: Expression[T]) = _between(left, right)._not(); + def $notBetween(left: Expression[T], right: Expression[T]) = $between(left, right).not; - def _gt(right: T): BooleanExpression = _gt(constant(right)); + def $gt(right: T): BooleanExpression = $gt(constant(right)); - def _gt(right: Expression[T]) = boolean(AFTER, this, right); + def $gt(right: Expression[T]) = boolean(AFTER, this, right); - def _goe(right: T): BooleanExpression = _goe(constant(right)); + def $goe(right: T): BooleanExpression = $goe(constant(right)); - def _goe(right: Expression[T]) = boolean(AOE, this, right); + def $goe(right: Expression[T]) = boolean(AOE, this, right); - def _loe(right: T): BooleanExpression = _loe(constant(right)); + def $loe(right: T): BooleanExpression = $loe(constant(right)); - def _loe(right: Expression[T]) = boolean(BOE, this, right); + def $loe(right: Expression[T]) = boolean(BOE, this, right); } trait NumberExpression[T <: Number with Comparable[T]] extends ComparableExpressionBase[T] { - - def _add(right: Expression[Number]) = number[T](getType, ADD, this, right); - - def _add(right: Number) : NumberExpression[T] = _add(constant(right)); - - def _abs() = number[T](getType, MathOps.ABS, this); - - def _sqrt() = number[java.lang.Double](classOf[java.lang.Double], MathOps.SQRT, this); - - def _min() = number[T](getType, AggOps.MIN_AGG, this); - - def _max() = number[T](getType, AggOps.MAX_AGG, this); - - def _lt(right: Number) : BooleanExpression = _lt(constant(right)); - - def _lt(right: Expression[Number]) = boolean(Ops.LT, this, right); - - def _in(right: Array[Number]) = boolean(IN, this, constant(asList(right:_*))); - - def _byteValue() = castToNum(classOf[java.lang.Byte]); - - def _doubleValue() = castToNum(classOf[java.lang.Double]); - - def _floatValue() = castToNum(classOf[java.lang.Float]); - - def _intValue() = castToNum(classOf[java.lang.Integer]); - - def _longValue() = castToNum(classOf[java.lang.Long]); - - def _shortValue() = castToNum(classOf[java.lang.Short]); - - def _ceil() = number[T](getType, MathOps.CEIL, this); - - def _floor() = number[T](getType, MathOps.FLOOR, this); - - def _round() = number[T](getType, MathOps.ROUND, this); - -// 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)); - - def _sum() = number[T](getType, AggOps.SUM_AGG, this); - - def _avg() = number[T](getType, AggOps.AVG_AGG, this); - - def _divide(right: Expression[Number]) = number[T](getType, Ops.MULT, this, right); - - def _divide(right: Number): NumberExpression[T] = _divide(constant(right)); - - def _goe(right: Number): BooleanExpression = _goe(constant(right)); - - def _goe(right: Expression[Number]) = boolean(Ops.GOE, this, right); - - def _gt(right: Number): BooleanExpression = _gt(constant(right)); - - def _gt(right: Expression[Number]) = boolean(Ops.GT, this, right); - - def _between(left: Number, right: Number): BooleanExpression = _between(constant(left), constant(right)); - - def _between(left: Expression[Number], right: Expression[Number]) = boolean(Ops.BETWEEN, this, left, right); - - def _notBetween(left: Number, right: Number): BooleanExpression = _between(left, right)._not(); - - def _notBetween(left: Expression[Number], right: Expression[Number]) = _between(left, right)._not(); - - def _loe(right: Number): BooleanExpression = _loe(constant(right)); - - def _loe(right: Expression[Number]) = boolean(Ops.LOE, this, right); - - def _mod(right: Expression[Number]) = number[T](getType, Ops.MOD, this, right); - - def _mod(right: Number): NumberExpression[T] = _mod(constant(right)); - - def _multiply(right: Expression[Number]) = number[T](getType, Ops.MULT, this, right); - - def _multiply(right: Number): NumberExpression[T] = _multiply(constant(right)); - - def _negate() = _multiply(-1); - - def _subtract(right: Expression[Number]) = number[T](getType, Ops.SUB, this, right); - - def _subtract(right: Number): NumberExpression[T] = _subtract(constant(right)); - - def _notIn(right: Array[Number]) = boolean(IN, this, constant(asList(right:_*)))._not(); + def $add(right: Expression[Number]) = number[T](getType, ADD, this, right); + + def $add(right: Number) : NumberExpression[T] = $add(constant(right)); + + def $goe(right: Number): BooleanExpression = $goe(constant(right)); + + def $goe(right: Expression[Number]) = boolean(Ops.GOE, this, right); + + def $gt(right: Number): BooleanExpression = $gt(constant(right)); + + def $gt(right: Expression[Number]) = boolean(Ops.GT, this, right); + + def $between(left: Number, right: Number): BooleanExpression = $between(constant(left), constant(right)); + + def $between(left: Expression[Number], right: Expression[Number]) = boolean(Ops.BETWEEN, this, left, right); + + def $notBetween(left: Number, right: Number): BooleanExpression = $between(left, right).not; + + def $notBetween(left: Expression[Number], right: Expression[Number]) = $between(left, right).not; + + def $loe(right: Number): BooleanExpression = $loe(constant(right)); + + def $loe(right: Expression[Number]) = boolean(Ops.LOE, this, right); + + def $lt(right: Number) : BooleanExpression = $lt(constant(right)); + + def $lt(right: Expression[Number]) = boolean(Ops.LT, this, right); + + def $in(right: Array[Number]) = boolean(IN, this, constant(asList(right:_*))); + + def $min() = number[T](getType, AggOps.MIN_AGG, this); + + def $max() = number[T](getType, AggOps.MAX_AGG, this); + + def $sum() = number[T](getType, AggOps.SUM_AGG, this); + + def $avg() = number[T](getType, AggOps.AVG_AGG, this); + + def $subtract(right: Expression[Number]) = number[T](getType, Ops.SUB, this, right); + + def $subtract(right: Number): NumberExpression[T] = $subtract(constant(right)); + + def $notIn(right: Array[Number]) = boolean(IN, this, constant(asList(right:_*))).not; + + def $divide(right: Expression[Number]) = number[T](getType, Ops.DIV, this, right); + + def $divide(right: Number): NumberExpression[T] = $divide(constant(right)); + + def $multiply(right: Expression[Number]) = number[T](getType, Ops.MULT, this, right); + + def $multiply(right: Number): NumberExpression[T] = $multiply(constant(right)); + + def $negate() = $multiply(-1); + + def $mod(right: Expression[Number]) = number[T](getType, Ops.MOD, this, right); + + def $mod(right: Number): NumberExpression[T] = $mod(constant(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]); + + def $doubleValue() = castToNum(classOf[java.lang.Double]); + + def $floatValue() = castToNum(classOf[java.lang.Float]); + + def $intValue() = castToNum(classOf[java.lang.Integer]); + + def $longValue() = castToNum(classOf[java.lang.Long]); + + def $shortValue() = castToNum(classOf[java.lang.Short]); + + def $ceil() = number[T](getType, MathOps.CEIL, this); + + def $floor() = number[T](getType, MathOps.FLOOR, this); + + def $round() = number[T](getType, MathOps.ROUND, this); + +// 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)); + private def castToNum[A <: Number with Comparable[A]](t : Class[A]): NumberExpression[A] = { if (t.equals(getType)){ this.asInstanceOf[NumberExpression[A]]; @@ -248,205 +248,205 @@ trait NumberExpression[T <: Number with Comparable[T]] extends ComparableExpress trait BooleanExpression extends ComparableExpression[java.lang.Boolean] with Predicate { - def _and(right: Predicate) = boolean(Ops.AND, this, right); - - def _or(right: Predicate) = boolean(Ops.OR, 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)); - - def _not() = boolean(Ops.NOT, this); + def $and(right: Predicate) = boolean(Ops.AND, this, right); - def not() = _not(); + def $or(right: Predicate) = boolean(Ops.OR, this, right); + + def $not() = not(); + + 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(alias: String): BooleanExpression = $as(new PathImpl[java.lang.Boolean](getType, alias)); + } trait StringExpression extends ComparableExpression[String] { + + def $like(right: String): BooleanExpression = $like(constant(right)); - def _append(right: Expression[String]) = string(Ops.CONCAT, this, right); + def $like(right: Expression[String]) = boolean(Ops.LIKE, this, right); + + def $append(right: Expression[String]) = string(Ops.CONCAT, this, right); // XXX "||" + + def $append(right: String): StringExpression = $append(constant(right)); - def _append(right: String): StringExpression = _append(constant(right)); + def $concat(right: Expression[String]) = $append(right); - def _indexOf(right: Expression[String]) = number[Integer](classOf[Integer], Ops.INDEX_OF, this, right); // XXX "index" / "idxOf" :( (?) + def $concat(right: String) = $append(right); + + def $prepend(right: Expression[String]) = string(Ops.CONCAT, right, this); - def _indexOf(right: String): NumberExpression[Integer] = _indexOf(constant(right)); // XXX "index" (?) + def $prepend(right: String) : StringExpression = $prepend(constant(right)); + + def $stringValue() = this; - def _indexOf(left: String, right: Int): NumberExpression[Integer] = _indexOf(constant(left), right); // XXX "index" (?) + def $lower() = $toLowerCase(); - def _indexOf(left: Expression[String], right: Int) = number[Integer](classOf[Integer], Ops.INDEX_OF_2ARGS, this, left, constant(right)); // XXX "index" (?) + def $upper() = $toUpperCase(); + + def $matches(right: Expression[String]) = boolean(Ops.MATCHES, this, right); // XXX "matchesExpr" - def _charAt(right: Expression[Integer]) = simple(classOf[Character], Ops.CHAR_AT, this, right); // XXX "char" + def $matches(right: String): BooleanExpression = $matches(constant(right)); // XXX "matchesExpr" + + def $indexOf(right: Expression[String]) = number[Integer](classOf[Integer], Ops.INDEX_OF, this, right); // XXX "index" / "idxOf" :( (?) - def _charAt(right: Integer): SimpleExpression[Character] = _charAt(constant(right)); // XXX "char" + def $indexOf(right: String): NumberExpression[Integer] = $indexOf(constant(right)); // XXX "index" (?) - def _concat(right: Expression[String]) = _append(right); // XXX "concatenate" / "merge" + def $indexOf(left: String, right: Int): NumberExpression[Integer] = $indexOf(constant(left), right); // XXX "index" (?) - def _concat(right: String) = _append(right); // XXX "concatenate" / "merge" + def $indexOf(left: Expression[String], right: Int) = number[Integer](classOf[Integer], Ops.INDEX_OF_2ARGS, this, left, constant(right)); // XXX "index" (?) - def _contains(right: Expression[String]) = boolean(Ops.STRING_CONTAINS, this, right); // XXX "has" / "haz" ;) + def $charAt(right: Expression[Integer]) = simple(classOf[Character], Ops.CHAR_AT, this, right); // XXX "char" - def _contains(right: String) : BooleanExpression = _contains(constant(right)); // XXX "has" + def $charAt(right: Integer): SimpleExpression[Character] = $charAt(constant(right)); // XXX "char" - def _endsWith(right: Expression[String]) = boolean(Ops.ENDS_WITH, this, right); // XXX "ends" / "endsIn" + def $contains(right: Expression[String]) = boolean(Ops.STRING_CONTAINS, this, right); // XXX "has" / "haz" ;) - def _endsWith(right: String): BooleanExpression = _endsWith(constant(right)); // XXX "ends" / "endsIn" + def $contains(right: String) : BooleanExpression = $contains(constant(right)); // XXX "has" - def _equalsIgnoreCase(right: Expression[String]) = boolean(Ops.EQ_IGNORE_CASE, this, right); // XXX "isIgnoreCase" / "eqIgnoreCase" + def $endsWith(right: Expression[String]) = boolean(Ops.ENDS_WITH, this, right); // XXX "ends" / "endsIn" - def _equalsIgnoreCase(right: String): BooleanExpression = _equalsIgnoreCase(constant(right)); // XXX "isIgnoreCase" / "eqIgnoreCase" + def $endsWith(right: String): BooleanExpression = $endsWith(constant(right)); // XXX "ends" / "endsIn" - def _isEmpty() = boolean(Ops.STRING_IS_EMPTY, this); // XXX "empty" + def $equalsIgnoreCase(right: Expression[String]) = boolean(Ops.EQ_IGNORE_CASE, this, right); // XXX "isIgnoreCase" / "eqIgnoreCase" - def _length() = number[Integer](classOf[Integer], Ops.STRING_LENGTH, this); // XXX "size" (RichString problem?) / "len" + def $equalsIgnoreCase(right: String): BooleanExpression = $equalsIgnoreCase(constant(right)); // XXX "isIgnoreCase" / "eqIgnoreCase" - def _matches(right: Expression[String]) = boolean(Ops.MATCHES, this, right); // XXX "matchesExpr" + def $isEmpty() = boolean(Ops.STRING_IS_EMPTY, this); // XXX "empty" - def _matches(right: String): BooleanExpression = _matches(constant(right)); // XXX "matchesExpr" + def $length() = number[Integer](classOf[Integer], Ops.STRING_LENGTH, this); // XXX "size" (RichString problem?) / "len" - def _startsWith(right: Expression[String]) = boolean(Ops.STARTS_WITH, this, right); // XXX "beginsWith" + def $startsWith(right: Expression[String]) = boolean(Ops.STARTS_WITH, this, right); // XXX "beginsWith" - def _startsWith(right: String) : BooleanExpression = _startsWith(constant(right)); // XXX "beginsWith" + def $startsWith(right: String) : BooleanExpression = $startsWith(constant(right)); // XXX "beginsWith" - def _substring(right: Int) = string(Ops.SUBSTR_1ARG, this, constant(right)); // XXX "substr" / "subString" / "sub" + def $substring(right: Int) = string(Ops.SUBSTR_1ARG, this, constant(right)); // XXX "substr" / "subString" / "sub" - def _substring(right: Int, arg1: Int) = string(Ops.SUBSTR_2ARGS, this, constant(right), constant(arg1)); // XXX "substr" / "subString" / "sub" + def $substring(right: Int, arg1: Int) = string(Ops.SUBSTR_2ARGS, this, constant(right), constant(arg1)); // XXX "substr" / "subString" / "sub" - def _toLowerCase() = string(Ops.LOWER); // XXX "lower" + def $toLowerCase() = string(Ops.LOWER, this); // XXX "lower" - def _toUpperCase() = string(Ops.UPPER); // XXX "upper" + def $toUpperCase() = string(Ops.UPPER, this); // XXX "upper" - def _trim() = string(Ops.TRIM); // XXX ??? + def $trim() = string(Ops.TRIM, this); // XXX ??? - def _prepend(right: Expression[String]) = string(Ops.CONCAT, right, this); + //override def $as(right: Path[String]): StringExpression; - def _prepend(right: String) : StringExpression = _prepend(constant(right)); + //override def $as(right: String): StringExpression; - //override def _as(right: Path[String]): StringExpression; + def $containsIgnoreCase(right: Expression[String]) = boolean(Ops.STRING_CONTAINS_IC, this, right); // XXX "hasIgnoreCase" - //override def _as(right: String): StringExpression; + def $containsIgnoreCase(right: String): BooleanExpression = $containsIgnoreCase(constant(right)); // ... - def _stringValue() = this; + def $endsWithIgnoreCase(right: Expression[String]) = boolean(Ops.ENDS_WITH_IC, this, right); - def _lower() = _toLowerCase(); + def $endsWithIgnoreCase(right: String): BooleanExpression = $endsWithIgnoreCase(constant(right)); - def _upper() = _toUpperCase(); + def $isNotEmpty() = $isEmpty().not; - def _containsIgnoreCase(right: Expression[String]) = boolean(Ops.STRING_CONTAINS_IC, this, right); // XXX "hasIgnoreCase" + def $startsWithIgnoreCase(right: Expression[String]) = boolean(Ops.STARTS_WITH_IC, this, right); - def _containsIgnoreCase(right: String): BooleanExpression = _containsIgnoreCase(constant(right)); // ... - - def _endsWithIgnoreCase(right: Expression[String]) = boolean(Ops.ENDS_WITH_IC, this, right); - - def _endsWithIgnoreCase(right: String): BooleanExpression = _endsWithIgnoreCase(constant(right)); - - def _isNotEmpty() = _isEmpty()._not(); - - def _like(right: String): BooleanExpression = _like(constant(right)); - - def _like(right: Expression[String]) = boolean(Ops.LIKE, this, right); - - def _startsWithIgnoreCase(right: Expression[String]) = boolean(Ops.STARTS_WITH_IC, this, right); - - def _startsWithIgnoreCase(right: String): BooleanExpression = _startsWithIgnoreCase(constant(right)); + def $startsWithIgnoreCase(right: String): BooleanExpression = $startsWithIgnoreCase(constant(right)); } 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] { - //override def _as(right: Path[T]): TimeExpression[T]; + //override def $as(right: Path[T]): TimeExpression[T]; - //override def _as(right: String): TimeExpression[T]; + //override def $as(right: String): TimeExpression[T]; - def _hour() = number(classOf[Integer], DateTimeOps.HOUR, this); + def $hour() = number(classOf[Integer], DateTimeOps.HOUR, this); - def _minute() = number(classOf[Integer], DateTimeOps.MINUTE, this); + def $minute() = number(classOf[Integer], DateTimeOps.MINUTE, this); - def _second() = number(classOf[Integer], DateTimeOps.SECOND, this); + def $second() = number(classOf[Integer], DateTimeOps.SECOND, this); - def _milliSecond() = number(classOf[Integer], DateTimeOps.MILLISECOND, this); + def $milliSecond() = number(classOf[Integer], DateTimeOps.MILLISECOND, this); } trait DateTimeExpression[T <: Comparable[_]] extends TemporalExpression[T] { - def _min() = dateTime(getType, AggOps.MIN_AGG, this); + def $min() = dateTime(getType, AggOps.MIN_AGG, this); - def _max() = dateTime(getType, AggOps.MAX_AGG, this); + def $max() = dateTime(getType, AggOps.MAX_AGG, this); - //override def _as(right: Path[T]): DateTimeExpression[T]; + //override def $as(right: Path[T]): DateTimeExpression[T]; - //override def _as(right: String): DateTimeExpression[T]; + //override def $as(right: String): DateTimeExpression[T]; - def _dayOfMonth() = number(classOf[Integer], DateTimeOps.DAY_OF_MONTH, this); + def $dayOfMonth() = number(classOf[Integer], DateTimeOps.DAY_OF_MONTH, this); - def _dayOfWeek() = number(classOf[Integer], DateTimeOps.DAY_OF_WEEK, this); + def $dayOfWeek() = number(classOf[Integer], DateTimeOps.DAY_OF_WEEK, this); - def _dayOfYear() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this); + def $dayOfYear() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this); - def _week() = number(classOf[Integer], DateTimeOps.WEEK, this); + def $week() = number(classOf[Integer], DateTimeOps.WEEK, this); - def _month() = number(classOf[Integer], DateTimeOps.MONTH, this); + def $month() = number(classOf[Integer], DateTimeOps.MONTH, this); - def _year() = number(classOf[Integer], DateTimeOps.YEAR, this); + def $year() = number(classOf[Integer], DateTimeOps.YEAR, this); - def _yearMonth() = number(classOf[Integer], DateTimeOps.YEAR_MONTH, this); + def $yearMonth() = number(classOf[Integer], DateTimeOps.YEAR_MONTH, this); - def _hour() = number(classOf[Integer], DateTimeOps.HOUR, this); + def $hour() = number(classOf[Integer], DateTimeOps.HOUR, this); - def _minute() = number(classOf[Integer], DateTimeOps.MINUTE, this); + def $minute() = number(classOf[Integer], DateTimeOps.MINUTE, this); - def _second() = number(classOf[Integer], DateTimeOps.SECOND, this); + def $second() = number(classOf[Integer], DateTimeOps.SECOND, this); - def _milliSecond() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this); + def $milliSecond() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this); } trait DateExpression[T <: Comparable[_]] extends TemporalExpression[T] { - def _min() = date(getType, AggOps.MIN_AGG, this); + def $min() = date(getType, AggOps.MIN_AGG, this); - def _max() = date(getType, AggOps.MAX_AGG, this); + def $max() = date(getType, AggOps.MAX_AGG, this); - //override def _as(right: Path[T]): DateExpression[T]; + //override def $as(right: Path[T]): DateExpression[T]; - //override def _as(right: String): DateExpression[T]; + //override def $as(right: String): DateExpression[T]; - def _dayOfMonth() = number(classOf[Integer], DateTimeOps.DAY_OF_MONTH, this); + def $dayOfMonth() = number(classOf[Integer], DateTimeOps.DAY_OF_MONTH, this); - def _dayOfWeek() = number(classOf[Integer], DateTimeOps.DAY_OF_WEEK, this); + def $dayOfWeek() = number(classOf[Integer], DateTimeOps.DAY_OF_WEEK, this); - def _dayOfYear() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this); + def $dayOfYear() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this); - def _week() = number(classOf[Integer], DateTimeOps.WEEK, this); + def $week() = number(classOf[Integer], DateTimeOps.WEEK, this); - def _month() = number(classOf[Integer], DateTimeOps.MONTH, this); + def $month() = number(classOf[Integer], DateTimeOps.MONTH, this); - def _year() = number(classOf[Integer], DateTimeOps.YEAR, this); + def $year() = number(classOf[Integer], DateTimeOps.YEAR, this); - def _yearMonth() = number(classOf[Integer], DateTimeOps.YEAR_MONTH, this); + def $yearMonth() = number(classOf[Integer], DateTimeOps.YEAR_MONTH, this); } trait EnumExpression[T <: Enum[T]] extends ComparableExpression[T] { - def _ordinal() = number(classOf[Integer], Ops.ORDINAL, this); + def $ordinal() = number(classOf[Integer], Ops.ORDINAL, this); - //override def _as(right: Path[T]): EnumExpression[T]; + //override def $as(right: Path[T]): EnumExpression[T]; - //override def _as(right: String): EnumExpression[T]; + //override def $as(right: String): EnumExpression[T]; } diff --git a/querydsl-scala/src/test/scala/com/mysema/query/scala/AliasTest.scala b/querydsl-scala/src/test/scala/com/mysema/query/scala/AliasTest.scala index 277dc1440..288ac7246 100644 --- a/querydsl-scala/src/test/scala/com/mysema/query/scala/AliasTest.scala +++ b/querydsl-scala/src/test/scala/com/mysema/query/scala/AliasTest.scala @@ -15,75 +15,116 @@ class AliasTest { @Test def String_Usage(){ // eq, ne - assertEquals("domainType.firstName = Hello", (domainType.firstName _eq "Hello").toString()); - assertEquals("domainType.firstName != Hello", (domainType.firstName _ne "Hello").toString()); + assertEquals("domainType.firstName = Hello", (domainType.firstName $eq "Hello").toString()); + assertEquals("domainType.firstName != Hello", (domainType.firstName $ne "Hello").toString()); + assertEquals("domainType.firstName != Hello", (domainType.firstName $ne "Hello").toString()); - assertEquals("domainType.firstName like Hello", (domainType.firstName _like "Hello").toString()); - assertEquals("domainType.firstName ASC", (domainType.firstName _asc).toString()); + assertEquals("domainType.firstName like Hello", (domainType.firstName $like "Hello").toString()); + assertEquals("domainType.firstName ASC", (domainType.firstName asc).toString()); + + // append + assertEquals("domainType.firstName + x", (domainType.firstName $append "x").toString()); + assertEquals("domainType.firstName + x", (domainType.firstName $append "x").toString()); // and - var andClause = (domainType.firstName _like "An%") _and (domainType.firstName _like "Be%"); + var andClause = (domainType.firstName $like "An%") $and (domainType.firstName $like "Be%"); assertEquals("domainType.firstName like An% && domainType.firstName like Be%", andClause.toString); // or - var orClause = (domainType.firstName _like "An%") _or (domainType.firstName _like "Be%"); + var orClause = (domainType.firstName $like "An%") $or (domainType.firstName $like "Be%"); assertEquals("domainType.firstName like An% || domainType.firstName like Be%", orClause.toString); // not - var notClause = (domainType.firstName _like "An%") _not; + var notClause = (domainType.firstName $like "An%") not; assertEquals("!domainType.firstName like An%", notClause.toString); - notClause = not (domainType.firstName _like "An%"); - assertEquals("!domainType.firstName like An%", notClause.toString); + notClause = not (domainType.firstName $like "An%"); + assertEquals("!domainType.firstName like An%", notClause.toString); + + // trim + assertEquals("trim(domainType.firstName)", (domainType.firstName $trim).toString); + + // isEmpty + assertEquals("empty(domainType.firstName)", (domainType.firstName $isEmpty).toString); } @Test def Number_Usage(){ - assertEquals("domainType.scalaInt < 5", (domainType.scalaInt _lt 5).toString); - assertEquals("domainType.javaInt < 5", (domainType.javaInt _lt 5).toString); - assertEquals("domainType.scalaInt between 2 and 3", (domainType.scalaInt _between (2,3)).toString); - assertEquals("domainType.javaInt between 2 and 3", (domainType.javaInt _between (2,3)).toString); + // lt + assertEquals("domainType.scalaInt < 5", (domainType.scalaInt $lt 5).toString); + assertEquals("domainType.javaInt < 5", (domainType.javaInt $lt 5).toString); + + // between + assertEquals("domainType.scalaInt between 2 and 3", (domainType.scalaInt $between (2,3)).toString); + assertEquals("domainType.javaInt between 2 and 3", (domainType.javaInt $between (2,3)).toString); + + // arithmetic + assertEquals("domainType.scalaInt + 3", (domainType.scalaInt $add 3).toString); + assertEquals("domainType.scalaInt - 3", (domainType.scalaInt $subtract 3).toString); + assertEquals("domainType.scalaInt / 3", (domainType.scalaInt $divide 3).toString); + assertEquals("domainType.scalaInt * 3", (domainType.scalaInt $multiply 3).toString); + assertEquals("domainType.scalaInt * -1", (domainType.scalaInt $negate).toString); + assertEquals("domainType.scalaInt % 4", (domainType.scalaInt $mod 4).toString); + assertEquals("round(domainType.scalaInt)", (domainType.scalaInt $round).toString); + assertEquals("floor(domainType.scalaInt)", (domainType.scalaInt $floor).toString); + assertEquals("ceil(domainType.scalaInt)", (domainType.scalaInt $ceil).toString); + + // casts + assertEquals("cast(domainType.javaInt,class java.lang.Long)", (domainType.javaInt $longValue).toString); + assertEquals("cast(domainType.scalaInt,class java.lang.Long)", (domainType.scalaInt $longValue).toString); + + // sqrt + assertEquals("sqrt(domainType.scalaInt)", (domainType.scalaInt $sqrt).toString); } @Test def Java_Collection_Usage(){ // size - assertEquals("size(domainType.javaCollection)", (domainType.javaCollection _size).toString); - assertEquals("size(domainType.javaSet)", (domainType.javaSet _size).toString); - assertEquals("size(domainType.javaList)", (domainType.javaList _size).toString); - assertEquals("size(domainType.javaMap)", (domainType.javaMap _size).toString); + assertEquals("size(domainType.javaCollection)", (domainType.javaCollection $size).toString); + assertEquals("size(domainType.javaSet)", (domainType.javaSet $size).toString); + assertEquals("size(domainType.javaList)", (domainType.javaList $size).toString); + assertEquals("size(domainType.javaMap)", (domainType.javaMap $size).toString); // is Empty - assertEquals("empty(domainType.javaCollection)", (domainType.javaCollection _isEmpty).toString); - assertEquals("empty(domainType.javaSet)", (domainType.javaSet _isEmpty).toString); - assertEquals("empty(domainType.javaList)", (domainType.javaList _isEmpty).toString); - assertEquals("empty(domainType.javaMap)", (domainType.javaMap _isEmpty).toString); + assertEquals("empty(domainType.javaCollection)", (domainType.javaCollection $isEmpty).toString); + assertEquals("empty(domainType.javaSet)", (domainType.javaSet $isEmpty).toString); + assertEquals("empty(domainType.javaList)", (domainType.javaList $isEmpty).toString); + assertEquals("empty(domainType.javaMap)", (domainType.javaMap $isEmpty).toString); // get - assertEquals("domainType.javaList.get(0) is not null", (domainType.javaList.get(0) _isNotNull).toString); - assertEquals("domainType.javaMap.get(xxx) is null", (domainType.javaMap.get("xxx") _isNull).toString); + assertEquals("domainType.javaList.get(0) is not null", (domainType.javaList.get(0) $isNotNull).toString); + assertEquals("domainType.javaMap.get(xxx) is null", (domainType.javaMap.get("xxx") $isNull).toString); // get + like - assertEquals("startsWith(domainType.javaMap.get(xxx),X)", (domainType.javaMap.get("xxx") _startsWith "X").toString); + assertEquals("startsWith(domainType.javaMap.get(xxx),X)", (domainType.javaMap.get("xxx") $startsWith "X").toString); } @Test def Scala_Collection_Usage(){ // size - assertEquals("size(domainType.scalaList)", (domainType.scalaList _size).toString); - assertEquals("size(domainType.scalaMap)", (domainType.scalaMap _size).toString); + assertEquals("size(domainType.scalaList)", (domainType.scalaList $size).toString); + assertEquals("size(domainType.scalaMap)", (domainType.scalaMap $size).toString); // is Empty - assertEquals("empty(domainType.scalaList)", (domainType.scalaList _isEmpty).toString); - assertEquals("empty(domainType.scalaMap)", (domainType.scalaMap _isEmpty).toString); + assertEquals("empty(domainType.scalaList)", (domainType.scalaList $isEmpty).toString); + assertEquals("empty(domainType.scalaMap)", (domainType.scalaMap $isEmpty).toString); // get - assertEquals("domainType.scalaList.get(0) is not null", (domainType.scalaList(0) _isNotNull).toString); - assertEquals("domainType.scalaList.get(0) is not null", (domainType.scalaList(0) _isNotNull).toString); - assertEquals("domainType.scalaMap.get(xxx) is null", (domainType.scalaMap("xxx") _isNull).toString); + assertEquals("domainType.scalaList.get(0) is not null", (domainType.scalaList(0) $isNotNull).toString); + assertEquals("domainType.scalaList.get(0) is not null", (domainType.scalaList(0) $isNotNull).toString); + assertEquals("domainType.scalaMap.get(xxx) is null", (domainType.scalaMap("xxx") $isNull).toString); + + // contains + assertEquals("X in domainType.scalaList", (domainType.scalaList $contains "X").toString); + assertEquals("X in domainType.javaList", (domainType.javaList $contains "X").toString); // get + like - assertEquals("startsWith(domainType.scalaMap.get(xxx),X)", (domainType.scalaMap("xxx") _startsWith "X").toString); + assertEquals("startsWith(domainType.scalaMap.get(xxx),X)", (domainType.scalaMap("xxx") $startsWith "X").toString); + } + + @Test + def Array_Usage(){ + assertEquals("size(domainType.array)", (domainType.array $size).toString()); } @Test diff --git a/querydsl-scala/src/test/scala/com/mysema/query/scala/ExampleDomain.scala b/querydsl-scala/src/test/scala/com/mysema/query/scala/ExampleDomain.scala index 3a12d97a5..ab1f55853 100644 --- a/querydsl-scala/src/test/scala/com/mysema/query/scala/ExampleDomain.scala +++ b/querydsl-scala/src/test/scala/com/mysema/query/scala/ExampleDomain.scala @@ -10,16 +10,17 @@ class DomainType { var lastName: String = null; - var scalaList: scala.List[DomainType] = null; + var scalaList: scala.List[String] = null; var scalaMap: scala.collection.Map[String,String] = null; - var javaCollection: java.util.Collection[DomainType] = null; + var javaCollection: java.util.Collection[String] = null; - var javaSet: java.util.Set[DomainType] = null; + var javaSet: java.util.Set[String] = null; - var javaList: java.util.List[DomainType] = null; + var javaList: java.util.List[String] = null; var javaMap: java.util.Map[String,String] = null; + var array: Array[String] = _; } \ No newline at end of file diff --git a/querydsl-scala/src/test/scala/com/mysema/query/scala/ExpressionTest.scala b/querydsl-scala/src/test/scala/com/mysema/query/scala/ExpressionTest.scala deleted file mode 100644 index 2c4b3ac9f..000000000 --- a/querydsl-scala/src/test/scala/com/mysema/query/scala/ExpressionTest.scala +++ /dev/null @@ -1,39 +0,0 @@ -package com.mysema.query.scala - -import org.junit.Test -import org.junit.Assert._ - -class ExpressionTest { - - var str = new StringPath("str"); - var num = new NumberPath[Integer](classOf[Integer],"num"); - - @Test - def String(){ - assertEquals("count(str)", str._count().toString); - assertEquals("str in [a, b]", str._in("a","b").toString); - //assertEquals("", str._in(List("a","b")).toString); - } - - @Test - def Operations(){ - // string - assertEquals("str = a", (str _eq "a").toString); - assertEquals("str != a", (str _ne "a").toString); - assertEquals("str > a", (str _gt "a").toString); - assertEquals("str < a", (str _lt "a").toString); - - // boolean - assertEquals("str = a || str = b", ((str _eq "a") _or (str _eq "b")).toString); - assertEquals("!str = a", (str _eq "a")._not().toString); - - // numeric -// assertEquals("num + 1", num add 1); // FIXME - } - - - - -} - -