diff --git a/querydsl-collections/src/test/java/com/mysema/query/collections/StringHandlingTest.java b/querydsl-collections/src/test/java/com/mysema/query/collections/StringHandlingTest.java index e59e43f37..174d368d4 100644 --- a/querydsl-collections/src/test/java/com/mysema/query/collections/StringHandlingTest.java +++ b/querydsl-collections/src/test/java/com/mysema/query/collections/StringHandlingTest.java @@ -47,14 +47,14 @@ public class StringHandlingTest extends AbstractQueryTest { @Test public void startsWithIgnoreCase() { - assertEquals(2, MiniApi.from(a, data).where(a.startsWith("AB", false)).count()); - assertEquals(2, MiniApi.from(a, data).where(a.startsWith("ab", false)).count()); + assertEquals(2, MiniApi.from(a, data).where(a.startsWithIgnoreCase("AB")).count()); + assertEquals(2, MiniApi.from(a, data).where(a.startsWithIgnoreCase("ab")).count()); } @Test public void endsWithIgnoreCase() { - assertEquals(2, MiniApi.from(a, data).where(a.endsWith("BC", false)).count()); - assertEquals(2, MiniApi.from(a, data).where(a.endsWith("bc", false)).count()); + assertEquals(2, MiniApi.from(a, data).where(a.endsWithIgnoreCase("BC")).count()); + assertEquals(2, MiniApi.from(a, data).where(a.endsWithIgnoreCase("bc")).count()); } } diff --git a/querydsl-core/src/main/java/com/mysema/query/types/expr/NumberExpression.java b/querydsl-core/src/main/java/com/mysema/query/types/expr/NumberExpression.java index f0810812a..e4123dd89 100644 --- a/querydsl-core/src/main/java/com/mysema/query/types/expr/NumberExpression.java +++ b/querydsl-core/src/main/java/com/mysema/query/types/expr/NumberExpression.java @@ -174,7 +174,6 @@ public abstract class NumberExpression> extends if (type.equals(getType())){ return (NumberExpression) this; }else{ -// return super.castToNum(type); return NumberOperation.create(type, Ops.NUMCAST, this, SimpleConstant.create(type)); } } diff --git a/querydsl-core/src/main/java/com/mysema/query/types/expr/StringExpression.java b/querydsl-core/src/main/java/com/mysema/query/types/expr/StringExpression.java index 8ab51e4dd..9a5b7814e 100644 --- a/querydsl-core/src/main/java/com/mysema/query/types/expr/StringExpression.java +++ b/querydsl-core/src/main/java/com/mysema/query/types/expr/StringExpression.java @@ -131,23 +131,6 @@ public abstract class StringExpression extends ComparableExpression { public BooleanExpression contains(String str) { return contains(StringConstant.create(str)); } - - /** - * Returns true if the given String is contained - * - * @param str - * @param caseSensitive case sensitivity of operation - * @return this.contains(str) - * @see java.lang.String#contains(CharSequence) - */ - @Deprecated - public BooleanExpression contains(Expression str, boolean caseSensitive) { - if (caseSensitive){ - return contains(str); - }else{ - return BooleanOperation.create(Ops.STRING_CONTAINS_IC, this, str); - } - } /** * @param str @@ -156,20 +139,7 @@ public abstract class StringExpression extends ComparableExpression { public BooleanExpression containsIgnoreCase(Expression str) { return BooleanOperation.create(Ops.STRING_CONTAINS_IC, this, str); } - - /** - * Returns true if the given String is contained - * - * @param str - * @param caseSensitive case sensitivity of operation - * @return this.contains(str) - * @see java.lang.String#contains(CharSequence) - */ - @Deprecated - public BooleanExpression contains(String str, boolean caseSensitive) { - return contains(StringConstant.create(str), caseSensitive); - } - + /** * @param str * @return @@ -188,23 +158,6 @@ public abstract class StringExpression extends ComparableExpression { public BooleanExpression endsWith(Expression str) { return BooleanOperation.create(Ops.ENDS_WITH, this, str); } - - /** - * Returns true if this ends with str - * - * @param str - * @param caseSensitive case sensitivity of operation - * @return - * @see java.lang.String#endsWith(String) - */ - @Deprecated - public BooleanExpression endsWith(Expression str, boolean caseSensitive) { - if (caseSensitive){ - return endsWith(str); - }else{ - return BooleanOperation.create(Ops.ENDS_WITH_IC, this, str); - } - } /** * @param str @@ -224,19 +177,6 @@ public abstract class StringExpression extends ComparableExpression { public BooleanExpression endsWith(String str) { return endsWith(StringConstant.create(str)); } - - /** - * Returns true if this ends with str - * - * @param str - * @param caseSensitive - * @return - * @see java.lang.String#endsWith(String) - */ - @Deprecated - public BooleanExpression endsWith(String str, boolean caseSensitive) { - return endsWith(StringConstant.create(str), caseSensitive); - } /** * @param str @@ -447,23 +387,6 @@ public abstract class StringExpression extends ComparableExpression { public BooleanExpression startsWith(Expression str) { return BooleanOperation.create(Ops.STARTS_WITH, this, str); } - - /** - * Return true if this starts with str - * - * @param str - * @param caseSensitive - * @return - * @see java.lang.String#startsWith(String) - */ - @Deprecated - public BooleanExpression startsWith(Expression str, boolean caseSensitive) { - if (caseSensitive){ - return startsWith(str); - }else{ - return BooleanOperation.create(Ops.STARTS_WITH_IC, this, str); - } - } /** * @param str @@ -483,19 +406,6 @@ public abstract class StringExpression extends ComparableExpression { public BooleanExpression startsWith(String str) { return startsWith(StringConstant.create(str)); } - - /** - * Return true if this starts with str - * - * @param str - * @param caseSensitive - * @return - * @see java.lang.String#startsWith(String) - */ - @Deprecated - public BooleanExpression startsWith(String str, boolean caseSensitive) { - return startsWith(StringConstant.create(str), caseSensitive); - } /** * @param str diff --git a/querydsl-core/src/test/java/com/mysema/query/Filters.java b/querydsl-core/src/test/java/com/mysema/query/Filters.java index aa4140a16..51e297fea 100644 --- a/querydsl-core/src/test/java/com/mysema/query/Filters.java +++ b/querydsl-core/src/test/java/com/mysema/query/Filters.java @@ -226,9 +226,9 @@ public class Filters { rv.add(expr.contains(knownValue.substring(0,1))); rv.add(expr.contains(knownValue.substring(1,2))); - rv.add(expr.contains(other, false)); - rv.add(expr.contains(knownValue.substring(0,1), false)); - rv.add(expr.contains(knownValue.substring(1,2), false)); + rv.add(expr.containsIgnoreCase(other)); + rv.add(expr.containsIgnoreCase(knownValue.substring(0,1))); + rv.add(expr.containsIgnoreCase(knownValue.substring(1,2))); rv.add(expr.endsWith(other)); rv.add(expr.endsWith(knownValue.substring(1))); diff --git a/querydsl-core/src/test/java/com/mysema/query/MatchingFilters.java b/querydsl-core/src/test/java/com/mysema/query/MatchingFilters.java index 4684f9795..8f11e59c4 100644 --- a/querydsl-core/src/test/java/com/mysema/query/MatchingFilters.java +++ b/querydsl-core/src/test/java/com/mysema/query/MatchingFilters.java @@ -166,21 +166,22 @@ public class MatchingFilters { rv.add(expr.contains(other.substring(1))); rv.add(expr.contains(other.substring(2))); - rv.add(expr.contains(other, false)); - rv.add(expr.contains(other.lower(), false)); - rv.add(expr.contains(other.upper(), false)); - rv.add(expr.contains(other.substring(0,1),false)); - rv.add(expr.contains(other.substring(0,2).lower(),false)); - rv.add(expr.contains(other.substring(1,2).upper(),false)); - rv.add(expr.contains(other.substring(1).lower(),false)); - rv.add(expr.contains(other.substring(2).upper(),false)); + rv.add(expr.containsIgnoreCase(other)); + rv.add(expr.containsIgnoreCase(other.lower())); + rv.add(expr.containsIgnoreCase(other.upper())); + rv.add(expr.containsIgnoreCase(other.substring(0,1))); + rv.add(expr.containsIgnoreCase(other.substring(0,2).lower())); + rv.add(expr.containsIgnoreCase(other.substring(1,2).upper())); + rv.add(expr.containsIgnoreCase(other.substring(1).lower())); + rv.add(expr.containsIgnoreCase(other.substring(2).upper())); rv.add(expr.endsWith(other)); - rv.add(expr.endsWith(other,false)); rv.add(expr.endsWith(other.substring(1))); rv.add(expr.endsWith(other.substring(2))); - rv.add(expr.endsWith(other.substring(1),false)); - rv.add(expr.endsWith(other.substring(2),false)); + + rv.add(expr.endsWithIgnoreCase(other)); + rv.add(expr.endsWithIgnoreCase(other.substring(1))); + rv.add(expr.endsWithIgnoreCase(other.substring(2))); rv.add(expr.eq(other)); rv.add(expr.equalsIgnoreCase(other)); @@ -230,12 +231,13 @@ public class MatchingFilters { rv.add(expr.ne(other)); } - rv.add(expr.startsWith(other)); - rv.add(expr.startsWith(other,false)); - rv.add(expr.startsWith(other.substring(0,1))); - rv.add(expr.startsWith(other.substring(0,1),false)); + rv.add(expr.startsWith(other)); + rv.add(expr.startsWith(other.substring(0,1))); rv.add(expr.startsWith(other.substring(0,2))); - rv.add(expr.startsWith(other.substring(0,2),false)); + + rv.add(expr.startsWithIgnoreCase(other)); + rv.add(expr.startsWithIgnoreCase(other.substring(0,1))); + rv.add(expr.startsWithIgnoreCase(other.substring(0,2))); if (module != Module.LUCENE){ rv.add(expr.substring(0,1).eq(other.substring(0,1))); diff --git a/querydsl-hql/src/test/java/com/mysema/query/AbstractStandardTest.java b/querydsl-hql/src/test/java/com/mysema/query/AbstractStandardTest.java index aec6cd40d..bf2ea8b6f 100644 --- a/querydsl-hql/src/test/java/com/mysema/query/AbstractStandardTest.java +++ b/querydsl-hql/src/test/java/com/mysema/query/AbstractStandardTest.java @@ -208,12 +208,12 @@ public abstract class AbstractStandardTest { // startsWith assertEquals(1, catQuery().where(cat.name.startsWith("R")).count()); assertEquals(0, catQuery().where(cat.name.startsWith("X")).count()); - assertEquals(1, catQuery().where(cat.name.startsWith("r",false)).count()); + assertEquals(1, catQuery().where(cat.name.startsWithIgnoreCase("r")).count()); // endsWith assertEquals(1, catQuery().where(cat.name.endsWith("h123")).count()); assertEquals(0, catQuery().where(cat.name.endsWith("X")).count()); - assertEquals(1, catQuery().where(cat.name.endsWith("H123",false)).count()); + assertEquals(1, catQuery().where(cat.name.endsWithIgnoreCase("H123")).count()); // contains assertEquals(1, catQuery().where(cat.name.contains("eli")).count()); diff --git a/querydsl-scala/pom.xml b/querydsl-scala/pom.xml index d97bc8eac..e1c6840ec 100644 --- a/querydsl-scala/pom.xml +++ b/querydsl-scala/pom.xml @@ -77,8 +77,23 @@ - - + + + + org.apache.maven.plugins + maven-eclipse-plugin + + + org.scala-ide.sdt.core.scalabuilder + + + org.scala-ide.sdt.core.scalanature + org.eclipse.jdt.core.javanature + + + + + 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 bd2beeb62..50cf47a5a 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 @@ -1,36 +1,88 @@ /* - * Copyright (c) 2010 Mysema Ltd. + * Copyright (c) 2010 Mysema Ltd. * All rights reserved. * */ package com.mysema.query.scala; -import com.mysema.query.alias.Alias._ +import com.mysema.query.alias._; + +import com.mysema.query.types._ import com.mysema.query.types.expr._ import com.mysema.query.types.path._ +import org.apache.commons.lang.StringUtils; + /** * @author tiwe * */ object Conversions { - def not(b: com.mysema.query.types.expr.BooleanExpression): com.mysema.query.types.expr.BooleanExpression = b.not() + val aliasFactory = new AliasFactory(new PathFactoryImpl()); - implicit def booleanPath(b: Boolean): BooleanPath = $(b); + def not(b: BooleanExpression) = b._not() - implicit def stringPath(s: String): StringPath = $(s); + def alias[T](cl: Class[T]): T = alias(cl, StringUtils.uncapitalize(cl.getSimpleName)); + + def alias[T](cl: Class[T], variable: String): T = aliasFactory.createAliasForVariable(cl, variable); - implicit def datePath(d: java.sql.Date): DatePath[java.sql.Date] = $(d); + def alias[T](cl: Class[T], expr: Expression[_ <: T]): T = aliasFactory.createAliasForExpr(cl, expr); - implicit def dateTimePath(d: java.util.Date): DateTimePath[java.util.Date] = $(d); + implicit def booleanPath(b: java.lang.Boolean): BooleanPath = aliasFactory.getCurrentAndReset(); - implicit def timePath(t: java.sql.Time): TimePath[java.sql.Time] = $(t); + implicit def stringPath(s: String): StringPath = aliasFactory.getCurrentAndReset(); + + implicit def datePath(d: java.sql.Date): DatePath[java.sql.Date] = aliasFactory.getCurrentAndReset(); + + implicit def dateTimePath(d: java.util.Date): DateTimePath[java.util.Date] = aliasFactory.getCurrentAndReset(); + + implicit def timePath(t: java.sql.Time): TimePath[java.sql.Time] = aliasFactory.getCurrentAndReset(); - implicit def comparablePath(c: Comparable[_]): ComparablePath[_] = $(c); + implicit def comparablePath(c: Comparable[_]): ComparablePath[_] = aliasFactory.getCurrentAndReset(); - implicit def simplePath(s: Object): SimplePath[_] = $(s); + implicit def simplePath(s: Object): SimplePath[_] = aliasFactory.getCurrentAndReset(); - //implicit def num[N <: Number & Comparable[N]](n: N): PNumber[N] = $(n); + //implicit def num[N <: Number with Comparable[N]](n: N): NumberPath[N] = $(n); + +} + +class PathFactoryImpl extends PathFactory { + + // TODO + def createArrayPath[T](t: Class[Array[T with Object]], md: PathMetadata[_]) = null; + + // TODO + def createEntityPath[T](t: Class[T], md: PathMetadata[_]) = Paths.simple(t, md); + + def createSimplePath[T](t: Class[T], md: PathMetadata[_]) = Paths.simple(t, md); + + def createComparablePath[T <: Comparable[_]](t: Class[T], md: PathMetadata[_]) = Paths.comparable(t, md); + + def createEnumPath[T <: Enum[T]](t: Class[T], md: PathMetadata[_]) = Paths.enum(t, md); + + def createDatePath[T <: Comparable[_]](t: Class[T], md: PathMetadata[_]) = Paths.date(t, md); + + def createTimePath[T <: Comparable[_]](t: Class[T], md: PathMetadata[_]) = Paths.time(t, md); + + def createDateTimePath[T <: Comparable[_]](t: Class[T], md: PathMetadata[_]) = Paths.dateTime(t, md); + + def createNumberPath[T <: Number with Comparable[T]](t: Class[T], md: PathMetadata[_]) = Paths.number(t, md); + + def createBooleanPath(md: PathMetadata[_]) = Paths.boolean(md); + + def createStringPath(md: PathMetadata[_]) = Paths.string(md); + + // TODO + def createListPath[T](t: Class[T], md: PathMetadata[_]) = null; + + // TODO + def createSetPath[T](t: Class[T], md: PathMetadata[_]) = null; + + // TODO + def createCollectionPath[T](t: Class[T], md: PathMetadata[_]) = null; + + // TODO + def createMapPath[K,V](k: Class[K], v: Class[V], md: PathMetadata[_]) = 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 e6d7ed1d5..9f7295743 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 @@ -4,18 +4,20 @@ * */ package com.mysema.query.scala; +import com.mysema.query.scala.Constants._ +import com.mysema.query.scala.Operations._ -import com.mysema.query.types._; -import com.mysema.query.types.Ops._; - -import com.mysema.query.scala.Constants._; -import com.mysema.query.scala.Operations._; - -import java.util.Collection; +import com.mysema.query.types._ +import com.mysema.query.types.Ops._ +import java.util.Collection import java.util.Arrays._; object Constants { + //def constant(value: java.lang.Integer) = ConstantImpl.create(value.intValue); + + def constant(value: String) = ConstantImpl.create(value); + def constant[T](value: T) = new ConstantImpl(value); } @@ -102,288 +104,293 @@ trait ComparableExpression[T <: Comparable[_]] extends ComparableExpressionBase[ } -trait NumberExpression[T <: Number with Comparable[T] ] extends ComparableExpressionBase[T] { +trait NumberExpression[T <: Number with Comparable[T]] extends ComparableExpressionBase[T] { - // TODO : get rid of asInstanceOf -// def _add(right: Expression[Number]) = number(getType, ADD, this, right); + def _add(right: Expression[Number]) = number[T](getType, ADD, this, right); -// def _add(right: Number) : NumberExpression[T] = _add(constant(right)); + def _add(right: Number) : NumberExpression[T] = _add(constant(right)); - def _abs(): NumberExpression[T]; + def _abs() = number[T](getType, MathOps.ABS, this); - def _sqrt(): NumberExpression[T]; + def _sqrt() = number[java.lang.Double](classOf[java.lang.Double], MathOps.SQRT, this); - def _min(): NumberExpression[T]; + def _min() = number[T](getType, AggOps.MIN_AGG, this); - def _max(): NumberExpression[T]; + def _max() = number[T](getType, AggOps.MAX_AGG, this); def _lt(right: Number) : BooleanExpression = _lt(constant(right)); - def _lt(right: Expression[Number]): BooleanExpression; + def _lt(right: Expression[Number]) = boolean(Ops.LT, this, right); - def _in(right: Array[Number]): BooleanExpression; + def _in(right: Array[Number]) = boolean(IN, this, constant(asList(right:_*))); - def _byteValue(): NumberExpression[java.lang.Byte]; + def _byteValue() = castToNum(classOf[java.lang.Byte]); - def _doubleValue(): NumberExpression[java.lang.Double]; + def _doubleValue() = castToNum(classOf[java.lang.Double]); - def _floatValue(): NumberExpression[java.lang.Float]; + def _floatValue() = castToNum(classOf[java.lang.Float]); - def _intValue(): NumberExpression[java.lang.Integer]; + def _intValue() = castToNum(classOf[java.lang.Integer]); - def _longValue(): NumberExpression[java.lang.Long]; + def _longValue() = castToNum(classOf[java.lang.Long]); - def _shortValue(): NumberExpression[java.lang.Short]; + def _shortValue() = castToNum(classOf[java.lang.Short]); - def _ceil(): NumberExpression[T]; + def _ceil() = number[T](getType, MathOps.CEIL, this); - def _floor(): NumberExpression[T]; + def _floor() = number[T](getType, MathOps.FLOOR, this); - def _random(): NumberExpression[T]; - - def _round(): NumberExpression[T]; + 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(): NumberExpression[T]; + def _sum() = number[T](getType, AggOps.SUM_AGG, this); - def _avg(): NumberExpression[T]; + def _avg() = number[T](getType, AggOps.AVG_AGG, this); - def _divide(right: Expression[Number]): NumberExpression[T]; + def _divide(right: Expression[Number]) = number[T](getType, Ops.MULT, this, right); - def _divide(right: Number): NumberExpression[T]; + def _divide(right: Number): NumberExpression[T] = _divide(constant(right)); - def _goe(right: Number): BooleanExpression; + def _goe(right: Number): BooleanExpression = _goe(constant(right)); - def _goe(right: Expression[Number]): BooleanExpression; + def _goe(right: Expression[Number]) = boolean(Ops.GOE, this, right); - def _gt(right: Number): BooleanExpression; + def _gt(right: Number): BooleanExpression = _gt(constant(right)); - def _gt(right: Expression[Number]): BooleanExpression; + def _gt(right: Expression[Number]) = boolean(Ops.GT, this, right); - def _between(left: Number, right: Number): BooleanExpression; + def _between(left: Number, right: Number): BooleanExpression = _between(constant(left), constant(right)); - def _between(left: Expression[T], right: Expression[T]): BooleanExpression; + def _between(left: Expression[Number], right: Expression[Number]) = boolean(Ops.BETWEEN, this, left, right); - def _notBetween(left: Number, right: Number): BooleanExpression; + def _notBetween(left: Number, right: Number): BooleanExpression = _between(left, right)._not(); - def _notBetween(left: Expression[T], right: Expression[T]): BooleanExpression; + def _notBetween(left: Expression[Number], right: Expression[Number]) = _between(left, right)._not(); - def _loe(right: Number): BooleanExpression; + def _loe(right: Number): BooleanExpression = _loe(constant(right)); - def _loe(right: Expression[Number]): BooleanExpression; + def _loe(right: Expression[Number]) = boolean(Ops.LOE, this, right); - def _mod(right: Expression[Number]): NumberExpression[T]; + def _mod(right: Expression[Number]) = number[T](getType, Ops.MOD, this, right); - def _mod(right: Number): NumberExpression[T]; + def _mod(right: Number): NumberExpression[T] = _mod(constant(right)); - def _multiply(right: Expression[Number]): NumberExpression[T]; + def _multiply(right: Expression[Number]) = number[T](getType, Ops.MULT, this, right); - def _multiply(right: Number): NumberExpression[T]; + def _multiply(right: Number): NumberExpression[T] = _multiply(constant(right)); - def _negate(): NumberExpression[T]; + def _negate() = _multiply(-1); - def _subtract(right: Expression[Number]): NumberExpression[T]; + def _subtract(right: Expression[Number]) = number[T](getType, Ops.SUB, this, right); - def _subtract(right: Number): NumberExpression[T]; + def _subtract(right: Number): NumberExpression[T] = _subtract(constant(right)); - def _notIn(right: Array[Number]): BooleanExpression; - - def _notIn(right: Array[Object]): BooleanExpression; + def _notIn(right: Array[Number]) = boolean(IN, this, constant(asList(right:_*)))._not(); + + 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, this, constant(t)); + } + } } -trait BooleanExpression extends ComparableExpression[java.lang.Boolean] { +trait BooleanExpression extends ComparableExpression[java.lang.Boolean] with Predicate { - 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); - override def _as(right: Path[T]) = boolean(ALIAS.asInstanceOf[Operator[T]], 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[T] = _as(new PathImpl[T](getType, alias)); + //override def _as(alias: String): BooleanExpression = _as(new PathImpl[java.lang.Boolean](getType, alias)); - def _not(): BooleanExpression; + def _not() = boolean(Ops.NOT, this); + + def not() = _not(); } trait StringExpression extends ComparableExpression[String] { - def _append(right: Expression[String]): StringExpression; + def _append(right: Expression[String]) = string(Ops.CONCAT, this, right); - def _append(right: String): StringExpression; + def _append(right: String): StringExpression = _append(constant(right)); - def _indexOf(right: Expression[String]): NumberExpression[Integer]; + def _indexOf(right: Expression[String]) = number[Integer](classOf[Integer], Ops.INDEX_OF, this, right); - def _indexOf(right: String): NumberExpression[Integer]; + def _indexOf(right: String): NumberExpression[Integer] = _indexOf(constant(right)); - def _indexOf(left: String, right: Int): NumberExpression[Integer]; + def _indexOf(left: String, right: Int): NumberExpression[Integer] = _indexOf(constant(left), right); - def _indexOf(left: Expression[String], right: Int): NumberExpression[Integer]; + def _indexOf(left: Expression[String], right: Int) = number[Integer](classOf[Integer], Ops.INDEX_OF_2ARGS, this, left, constant(right)); - def _charAt(right: Expression[String]): SimpleExpression[Character]; + def _charAt(right: Expression[Integer]) = simple(classOf[Character], Ops.CHAR_AT, this, right); - def _charAt(right: Int): SimpleExpression[Character]; + def _charAt(right: Integer): SimpleExpression[Character] = _charAt(constant(right)); - def _concat(right: Expression[String]): StringExpression; + def _concat(right: Expression[String]) = _append(right); - def _concat(right: String): StringExpression; + def _concat(right: String) = _append(right); - def _contains(right: Expression[String]): BooleanExpression; + def _contains(right: Expression[String]) = boolean(Ops.STRING_CONTAINS, this, right); - def _contains(right: String): BooleanExpression; + def _contains(right: String) : BooleanExpression = _contains(constant(right)); - def _endsWith(right: Expression[String]): BooleanExpression; + def _endsWith(right: Expression[String]) = boolean(Ops.ENDS_WITH, this, right); - def _endsWith(right: String): BooleanExpression; + def _endsWith(right: String): BooleanExpression = _endsWith(constant(right)); - def _equalsIgnoreCase(right: Expression[String]): BooleanExpression; + def _equalsIgnoreCase(right: Expression[String]) = boolean(Ops.EQ_IGNORE_CASE, this, right); - def _equalsIgnoreCase(right: String): BooleanExpression; + def _equalsIgnoreCase(right: String): BooleanExpression = _equalsIgnoreCase(constant(right)); - def _isEmpty(): BooleanExpression; + def _isEmpty() = boolean(Ops.STRING_IS_EMPTY, this); - def _length(): NumberExpression[Integer]; + def _length() = number[Integer](classOf[Integer], Ops.STRING_LENGTH, this); - def _matches(right: Expression[String]): BooleanExpression; + def _matches(right: Expression[String]) = boolean(Ops.MATCHES, this, right); - def _matches(right: String): BooleanExpression; + def _matches(right: String): BooleanExpression = _matches(constant(right)); - def _startsWith(right: Expression[String]): BooleanExpression; + def _startsWith(right: Expression[String]) = boolean(Ops.STARTS_WITH, this, right); - def _startsWith(right: String): BooleanExpression; + def _startsWith(right: String) : BooleanExpression = _startsWith(constant(right)); - def _substring(right: Int): StringExpression; + def _substring(right: Int) = string(Ops.SUBSTR_1ARG, this, constant(right)); - def _substring(right: Int, arg1: Int): StringExpression; + def _substring(right: Int, arg1: Int) = string(Ops.SUBSTR_2ARGS, this, constant(right), constant(arg1)); - def _toLowerCase(): StringExpression; + def _toLowerCase() = string(Ops.LOWER); - def _toUpperCase(): StringExpression; + def _toUpperCase() = string(Ops.UPPER); - def _trim(): StringExpression; + def _trim() = string(Ops.TRIM); - def _prepend(right: Expression[String]): StringExpression; + def _prepend(right: Expression[String]) = string(Ops.CONCAT, right, this); - def _prepend(right: String): StringExpression; + def _prepend(right: String) : StringExpression = _prepend(constant(right)); - override def _as(right: Path[String]): StringExpression; + //override def _as(right: Path[String]): StringExpression; - override def _as(right: String): StringExpression; + //override def _as(right: String): StringExpression; - def _stringValue(): StringExpression; + def _stringValue() = this; - def _lower(): StringExpression; + def _lower() = _toLowerCase(); - def _upper(): StringExpression; + def _upper() = _toUpperCase(); - def _containsIgnoreCase(right: Expression[String]): BooleanExpression; + def _containsIgnoreCase(right: Expression[String]) = boolean(Ops.STRING_CONTAINS_IC, this, right); - def _containsIgnoreCase(right: String): BooleanExpression; + def _containsIgnoreCase(right: String): BooleanExpression = _containsIgnoreCase(constant(right)); - def _endsWithIgnoreCase(right: Expression[String]): BooleanExpression; + def _endsWithIgnoreCase(right: Expression[String]) = boolean(Ops.ENDS_WITH_IC, this, right); - def _endsWithIgnoreCase(right: String): BooleanExpression; + def _endsWithIgnoreCase(right: String): BooleanExpression = _endsWithIgnoreCase(constant(right)); - def _isNotEmpty(): BooleanExpression; + def _isNotEmpty() = _isEmpty()._not(); - def _like(right: String): BooleanExpression; + def _like(right: String): BooleanExpression = _like(constant(right)); - def _like(right: Expression[String]): BooleanExpression; + def _like(right: Expression[String]) = boolean(Ops.LIKE, this, right); - def _startsWithIgnoreCase(right: Expression[String]): BooleanExpression; + def _startsWithIgnoreCase(right: Expression[String]) = boolean(Ops.STARTS_WITH_IC, this, right); - def _startsWithIgnoreCase(right: String): BooleanExpression; + def _startsWithIgnoreCase(right: String): BooleanExpression = _startsWithIgnoreCase(constant(right)); } trait TemporalExpression[T <: Comparable[_]] extends ComparableExpression[T] { - def _after(right: T): BooleanExpression; + def _after(right: T) = _gt(right); - def _after(right: Expression[T]): BooleanExpression; + def _after(right: Expression[T]) = _gt(right); - def _before(right: T): BooleanExpression; + def _before(right: T) = _lt(right); - def _before(right: Expression[T]): BooleanExpression; + 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(): NumberExpression[Integer]; + def _hour() = number(classOf[Integer], DateTimeOps.HOUR, this); - def _minute(): NumberExpression[Integer]; + def _minute() = number(classOf[Integer], DateTimeOps.MINUTE, this); - def _second(): NumberExpression[Integer]; + def _second() = number(classOf[Integer], DateTimeOps.SECOND, this); - def _milliSecond(): NumberExpression[Integer]; + def _milliSecond() = number(classOf[Integer], DateTimeOps.MILLISECOND, this); } trait DateTimeExpression[T <: Comparable[_]] extends TemporalExpression[T] { - def _min(): DateTimeExpression[T]; + def _min() = dateTime(getType, AggOps.MIN_AGG, this); - def _max(): DateTimeExpression[T]; + 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(): NumberExpression[Integer]; + def _dayOfMonth() = number(classOf[Integer], DateTimeOps.DAY_OF_MONTH, this); - def _dayOfWeek(): NumberExpression[Integer]; + def _dayOfWeek() = number(classOf[Integer], DateTimeOps.DAY_OF_WEEK, this); - def _dayOfYear(): NumberExpression[Integer]; + def _dayOfYear() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this); - def _week(): NumberExpression[Integer]; + def _week() = number(classOf[Integer], DateTimeOps.WEEK, this); - def _month(): NumberExpression[Integer]; + def _month() = number(classOf[Integer], DateTimeOps.MONTH, this); - def _year(): NumberExpression[Integer]; + def _year() = number(classOf[Integer], DateTimeOps.YEAR, this); - def _yearMonth(): NumberExpression[Integer]; + def _yearMonth() = number(classOf[Integer], DateTimeOps.YEAR_MONTH, this); - def _hour(): NumberExpression[Integer]; + def _hour() = number(classOf[Integer], DateTimeOps.HOUR, this); - def _minute(): NumberExpression[Integer]; + def _minute() = number(classOf[Integer], DateTimeOps.MINUTE, this); - def _second(): NumberExpression[Integer]; + def _second() = number(classOf[Integer], DateTimeOps.SECOND, this); - def _milliSecond(): NumberExpression[Integer]; + def _milliSecond() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this); } trait DateExpression[T <: Comparable[_]] extends TemporalExpression[T] { - def _min(): DateExpression[T]; + def _min() = date(getType, AggOps.MIN_AGG, this); - def _max(): DateExpression[T]; + 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(): NumberExpression[Integer]; + def _dayOfMonth() = number(classOf[Integer], DateTimeOps.DAY_OF_MONTH, this); - def _dayOfWeek(): NumberExpression[Integer]; + def _dayOfWeek() = number(classOf[Integer], DateTimeOps.DAY_OF_WEEK, this); - def _dayOfYear(): NumberExpression[Integer]; + def _dayOfYear() = number(classOf[Integer], DateTimeOps.DAY_OF_YEAR, this); - def _week(): NumberExpression[Integer]; + def _week() = number(classOf[Integer], DateTimeOps.WEEK, this); - def _month(): NumberExpression[Integer]; + def _month() = number(classOf[Integer], DateTimeOps.MONTH, this); - def _year(): NumberExpression[Integer]; + def _year() = number(classOf[Integer], DateTimeOps.YEAR, this); - def _yearMonth(): NumberExpression[Integer]; + def _yearMonth() = number(classOf[Integer], DateTimeOps.YEAR_MONTH, this); } @@ -391,9 +398,9 @@ trait EnumExpression[T <: Enum[T]] extends ComparableExpression[T] { 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/main/scala/com/mysema/query/scala/Operations.scala b/querydsl-scala/src/main/scala/com/mysema/query/scala/Operations.scala index 48871cdf8..1bd643d89 100644 --- a/querydsl-scala/src/main/scala/com/mysema/query/scala/Operations.scala +++ b/querydsl-scala/src/main/scala/com/mysema/query/scala/Operations.scala @@ -17,11 +17,19 @@ object Operations { def comparable[T <: Comparable[_]](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]*) = new ComparableOperation[T](t, operator, args:_*); - def number[T <: Number with Comparable[T]](t: Class[T], operator: Operator[_ >: T], args: Expression[_]*) = new NumberOperation[T](t, operator, args:_*); + def date[T <: Comparable[_]](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]*) = new DateOperation[T](t, operator, args:_*); + + def dateTime[T <: Comparable[_]](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]*) = new DateTimeOperation[T](t, operator, args:_*); + + def time[T <: Comparable[_]](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]*) = new TimeOperation[T](t, operator, args:_*); + + def number[T <: Number with Comparable[T]](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]*) = new NumberOperation[T](t, operator, args:_*); def boolean(operator: Operator[_ >: java.lang.Boolean], args: Expression[_]*) = new BooleanOperation(operator, args:_*); - def string(operator: Operator[_ >: String], args: Expression[_]*) = new StringOperation(operator, args:_*); + def string(operator: Operator[_ >: String], args: Expression[_]*) = new StringOperation(operator, args:_*); + + def enum[T <: Enum[T]](t: Class[T], operator: Operator[_ >: T], args: Expression[_]*) = new EnumOperation[T](t, operator, args:_*); } class SimpleOperation[T](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]* ) @@ -64,7 +72,7 @@ class TimeOperation[T <: Comparable[_]](t: Class[_ <: T], operator: Operator[_ > } -class EnumOperation[T <: Enum[T]](t: Class[_ <: T], operator: Operator[_ >: T], args: Expression[_]* ) +class EnumOperation[T <: Enum[T]](t: Class[T], operator: Operator[_ >: T], args: Expression[_]* ) extends OperationImpl[T](t, operator, args:_*) with EnumExpression[T]{ } diff --git a/querydsl-scala/src/main/scala/com/mysema/query/scala/Paths.scala b/querydsl-scala/src/main/scala/com/mysema/query/scala/Paths.scala index e69de29bb..25c5b4b2e 100644 --- a/querydsl-scala/src/main/scala/com/mysema/query/scala/Paths.scala +++ b/querydsl-scala/src/main/scala/com/mysema/query/scala/Paths.scala @@ -0,0 +1,97 @@ +package com.mysema.query.scala; + +import com.mysema.query.types._; +import com.mysema.query.types.PathMetadataFactory._; + +/** + * @author tiwe + * + */ +object Paths { + + def simple[T](t: Class[_ <: T], md: PathMetadata[_]) = new SimplePath[T](t, md); + + def comparable[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_]) = new ComparablePath[T](t, md); + + def date[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_]) = new DatePath[T](t, md); + + def dateTime[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_]) = new DateTimePath[T](t, md); + + def time[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_]) = new TimePath[T](t, md); + + def number[T <: Number with Comparable[T]](t: Class[_ <: T], md: PathMetadata[_]) = new NumberPath[T](t, md); + + def boolean(md: PathMetadata[_]) = new BooleanPath(md); + + def string(md: PathMetadata[_]) = new StringPath(md); + + def enum[T <: Enum[T]](t: Class[T], md: PathMetadata[_]) = new EnumPath[T](t, md); +} + +class SimplePath[T](t: Class[_ <: T], md: PathMetadata[_] ) + extends PathImpl[T](t, md) with SimpleExpression[T]{ + + def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable)); + +} + +class ComparablePath[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_] ) + extends PathImpl[T](t, md) with ComparableExpression[T]{ + + def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable)); + +} + +class NumberPath[T <: Number with Comparable[T]](t: Class[_ <: T], md: PathMetadata[_] ) + extends PathImpl[T](t, md) with NumberExpression[T]{ + + def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable)); +} + +class BooleanPath(md: PathMetadata[_] ) + extends PathImpl[java.lang.Boolean](classOf[java.lang.Boolean], md) with BooleanExpression{ + + def this(variable: String) = this(forVariable(variable)); + +} + +class StringPath(md: PathMetadata[_] ) + extends PathImpl[String](classOf[String], md) with StringExpression{ + + def this(variable: String) = this(forVariable(variable)); + +} + +class DatePath[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_] ) + extends PathImpl[T](t, md) with DateExpression[T]{ + + def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable)); + +} + +class DateTimePath[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_] ) + extends PathImpl[T](t, md) with DateTimeExpression[T]{ + + def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable)); + +} + +class TimePath[T <: Comparable[_]](t: Class[_ <: T], md: PathMetadata[_] ) + extends PathImpl[T](t, md) with TimeExpression[T]{ + + def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable)); + +} + +class EnumPath[T <: Enum[T]](t: Class[_ <: T], md: PathMetadata[_] ) + extends PathImpl[T](t, md) with EnumExpression[T]{ + + def this(t: Class[_ <: T], variable: String) = this(t, forVariable(variable)); + +} + +// TODO : ListPath + +// TODO : SetPath + +// TODO : CollectionPath \ No newline at end of file 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 582930936..dd7d2376c 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 @@ -1,6 +1,5 @@ package com.mysema.query.scala -import com.mysema.query.alias.Alias._ import com.mysema.query.types.path._ import com.mysema.query.sql.SQLSubQuery @@ -14,38 +13,38 @@ class AliasTest { var domainType = alias(classOf[DomainType]) - @Test - def Explicit_Cast(){ - assertEquals("domainType.firstName", $(domainType.firstName).toString); - } +// @Test +// def Explicit_Cast(){ +// assertEquals("domainType.firstName", $(domainType.firstName).toString); +// } @Test def Implicit_Cast1(){ var path: StringPath = domainType.firstName; - assertEquals("domainType.firstName like Hello", (path like "Hello").toString()); - assertEquals("domainType.firstName ASC", (path asc).toString()); - assertEquals("domainType.firstName = Hello", (path eq "Hello").toString()); - assertEquals("domainType.firstName != Hello", (path ne "Hello").toString()); + assertEquals("domainType.firstName like Hello", (path _like "Hello").toString()); + assertEquals("domainType.firstName ASC", (path _asc).toString()); + assertEquals("domainType.firstName = Hello", (path _eq "Hello").toString()); + assertEquals("domainType.firstName != Hello", (path _ne "Hello").toString()); } @Test def Implicit_Cast2(){ - 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()); // 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%"); + notClause = not (domainType.firstName _like "An%"); assertEquals("!domainType.firstName like An%", notClause.toString); // FIXME : "eq" and "ne" are already reserved @@ -53,35 +52,38 @@ class AliasTest { // assertEquals("domainType.firstName != Hello", (domainType.firstName ne "Hello").toString()); } - @Test - def Expression_in_SubQuery(){ - // list - query().from ($(domainType)) - .where (domainType.firstName like "Rob%") - .orderBy (domainType.firstName asc) - .list ($(domainType)); // FIXME - - // unique result - query().from ($(domainType)) - .where (domainType.firstName like "Rob%") - .orderBy (domainType.firstName asc) - .unique ($(domainType)); // FIXME - - // long where - query().from ($(domainType)) - .where ( - domainType.firstName like "Rob%", - domainType.lastName like "An%" - ) - .orderBy (domainType.firstName asc) - .list ($(domainType)); // FIXME - } +// @Test +// def Expression_in_SubQuery(){ +// // list +// query().from (domainType) +// .where (domainType.firstName _like "Rob%") +// .orderBy (domainType.firstName _asc) +// .list (domainType); // FIXME +// +// // unique result +// query().from (domainType) +// .where (domainType.firstName _like "Rob%") +// .orderBy (domainType.firstName _asc) +// .unique (domainType); // FIXME +// +// // long where +// query().from (domainType) +// .where ( +// domainType.firstName _like "Rob%", +// domainType.lastName _like "An%" +// ) +// .orderBy (domainType.firstName _asc) +// .list (domainType); // FIXME +// } def query() = new SQLSubQuery(); } class DomainType { + var firstName: String = null; + var lastName: String = null; + } \ 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 index 81c8e8ed7..2c4b3ac9f 100644 --- a/querydsl-scala/src/test/scala/com/mysema/query/scala/ExpressionTest.scala +++ b/querydsl-scala/src/test/scala/com/mysema/query/scala/ExpressionTest.scala @@ -1,31 +1,39 @@ package com.mysema.query.scala -import com.mysema.query.types.path._ - import org.junit.Test import org.junit.Assert._ class ExpressionTest { var str = new StringPath("str"); - var num = new NumberPath(classOf[Integer],"num"); + 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); + 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); + 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 } + + + }