mirror of
https://github.com/querydsl/querydsl.git
synced 2026-06-30 21:08:30 +08:00
worked on Scala support
This commit is contained in:
Timo Westkämper
parent
c70893fdcd
commit
2e87b8523b
@ -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());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -174,7 +174,6 @@ public abstract class NumberExpression<D extends Number & Comparable<?>> extends
|
||||
if (type.equals(getType())){
|
||||
return (NumberExpression<A>) this;
|
||||
}else{
|
||||
// return super.castToNum(type);
|
||||
return NumberOperation.create(type, Ops.NUMCAST, this, SimpleConstant.create(type));
|
||||
}
|
||||
}
|
||||
|
||||
@ -131,23 +131,6 @@ public abstract class StringExpression extends ComparableExpression<String> {
|
||||
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<String> 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<String> {
|
||||
public BooleanExpression containsIgnoreCase(Expression<String> 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<String> {
|
||||
public BooleanExpression endsWith(Expression<String> 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<String> 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<String> {
|
||||
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<String> {
|
||||
public BooleanExpression startsWith(Expression<String> 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<String> 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<String> {
|
||||
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
|
||||
|
||||
@ -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)));
|
||||
|
||||
@ -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)));
|
||||
|
||||
@ -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());
|
||||
|
||||
@ -77,8 +77,23 @@
|
||||
</goals>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</plugin>
|
||||
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-eclipse-plugin</artifactId>
|
||||
<configuration>
|
||||
<buildcommands>
|
||||
<buildcommand>org.scala-ide.sdt.core.scalabuilder</buildcommand>
|
||||
</buildcommands>
|
||||
<projectnatures>
|
||||
<projectnature>org.scala-ide.sdt.core.scalanature</projectnature>
|
||||
<projectnature>org.eclipse.jdt.core.javanature</projectnature>
|
||||
</projectnatures>
|
||||
</configuration>
|
||||
</plugin>
|
||||
</plugins>
|
||||
|
||||
</build>
|
||||
|
||||
</project>
|
||||
|
||||
@ -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;
|
||||
|
||||
}
|
||||
|
||||
@ -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];
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -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]{
|
||||
|
||||
}
|
||||
|
||||
@ -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
|
||||
@ -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;
|
||||
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user