CodeCow/querydsl
1
0
Fork 0
mirror of https://github.com/querydsl/querydsl.git synced 2026-06-13 21:01:01 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

added Date, DateTime and Time support to alias creation

Browse Source
This commit is contained in:
Timo Westkämper 2009-06-18 09:12:54 +00:00
parent f6b797dfbc
commit 5d4c3093fa
24 changed files with 296 additions and 544 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
querydsl-collections/src/test/java/com/mysema/query/collections/AliasTest.java
View File

@ -93,8 +93,7 @@ public class AliasTest extends AbstractQueryTest {
// 2
try {
from(c, cats).where(
$(c.getMate().getName().toUpperCase()).eq("MOE"));
from(c, cats).where($(c.getMate().getName().toUpperCase()).eq("MOE"));
fail("expected NPE");
} catch (NullPointerException ne) {
// expected

4
querydsl-collections/src/test/java/com/mysema/query/collections/MathFunctionTest.java
View File

@ -26,8 +26,8 @@ public class MathFunctionTest extends AbstractQueryTest {
@Test
public void test() {
Cat c = alias(Cat.class, "c");
Expr<Integer> i = new EConstant<Integer>(1);
Expr<Double> d = new EConstant<Double>(1.0);
Expr<Integer> i = EConstant.create(1);
Expr<Double> d = EConstant.create(1.0);
from(c, cats).list(MathFunctions.abs(i), MathFunctions.acos(d),
MathFunctions.asin(d), MathFunctions.atan(d),
MathFunctions.ceil(d), MathFunctions.cos(d),

74
querydsl-core/src/main/java/com/mysema/query/alias/AliasAwarePathFactory.java
View File

@ -14,6 +14,8 @@ import com.mysema.query.types.path.PBoolean;
import com.mysema.query.types.path.PBooleanArray;
import com.mysema.query.types.path.PComparable;
import com.mysema.query.types.path.PComparableArray;
import com.mysema.query.types.path.PDate;
import com.mysema.query.types.path.PDateTime;
import com.mysema.query.types.path.PEntity;
import com.mysema.query.types.path.PEntityCollection;
import com.mysema.query.types.path.PEntityList;
@ -21,6 +23,7 @@ import com.mysema.query.types.path.PEntityMap;
import com.mysema.query.types.path.PNumber;
import com.mysema.query.types.path.PString;
import com.mysema.query.types.path.PStringArray;
import com.mysema.query.types.path.PTime;
/**
* AliasAwareExprFactory extends the SimpleExprFactory to return thread bound
@ -29,8 +32,10 @@ import com.mysema.query.types.path.PStringArray;
* @author tiwe
* @version $Id$
*/
class AliasAwarePathFactory extends SimplePathFactory {
class AliasAwarePathFactory implements PathFactory {
private SimplePathFactory factory = new SimplePathFactory();
private final AliasFactory aliasFactory;
public AliasAwarePathFactory(AliasFactory aliasFactory) {
@ -51,27 +56,36 @@ class AliasAwarePathFactory extends SimplePathFactory {
public PBoolean createBoolean(Boolean arg) {
PBoolean rv = aliasFactory.<PBoolean> getCurrentAndReset();
return rv != null ? rv : super.createBoolean(arg);
return rv != null ? rv : factory.createBoolean(arg);
}
public PBooleanArray createBooleanArray(Boolean[] args) {
PBooleanArray rv = aliasFactory.<PBooleanArray> getCurrentAndReset();
return rv != null ? rv : super.createBooleanArray(args);
}
public <D> PEntityCollection<D> createEntityCollection(Collection<D> arg) {
PEntityCollection<D> rv = aliasFactory.<PEntityCollection<D>> getCurrentAndReset();
return rv != null ? rv : super.createEntityCollection(arg);
return rv != null ? rv : factory.createBooleanArray(args);
}
public <D extends Comparable<?>> PComparable<D> createComparable(D arg) {
PComparable<D> rv = aliasFactory.<PComparable<D>> getCurrentAndReset();
return rv != null ? rv : super.createComparable(arg);
return rv != null ? rv : factory.createComparable(arg);
}
public <D extends Number & Comparable<?>> PNumber<D> createNumber(D arg) {
PNumber<D> rv = aliasFactory.<PNumber<D>> getCurrentAndReset();
return rv != null ? rv : super.createNumber(arg);
public <D extends Comparable<?>> PComparableArray<D> createComparableArray(D[] args) {
PComparableArray<D> rv = aliasFactory.<PComparableArray<D>> getCurrentAndReset();
return rv != null ? rv : factory.createComparableArray(args);
}
@SuppressWarnings("unchecked")
@Override
public <D extends Comparable> PDate<D> createDate(D arg) {
PDate<D> rv = aliasFactory.<PDate<D>>getCurrentAndReset();
return rv != null ? rv : factory.createDate(arg);
}
@SuppressWarnings("unchecked")
@Override
public <D extends Comparable> PDateTime<D> createDateTime(D arg) {
PDateTime<D> rv = aliasFactory.<PDateTime<D>>getCurrentAndReset();
return rv != null ? rv : factory.createDateTime(arg);
}
@SuppressWarnings("unchecked")
@ -82,33 +96,45 @@ class AliasAwarePathFactory extends SimplePathFactory {
} else if (arg instanceof ManagedObject) {
return (PEntity<D>) ((ManagedObject) arg).__mappedPath();
} else {
return super.createEntity(arg);
return factory.createEntity(arg);
}
}
public <D extends Comparable<?>> PComparableArray<D> createComparableArray(D[] args) {
PComparableArray<D> rv = aliasFactory.<PComparableArray<D>> getCurrentAndReset();
return rv != null ? rv : super.createComparableArray(args);
}
public <K, V> PEntityMap<K, V> createEntityMap(Map<K, V> arg) {
PEntityMap<K, V> rv = aliasFactory.<PEntityMap<K, V>> getCurrentAndReset();
return rv != null ? rv : super.createEntityMap(arg);
public <D> PEntityCollection<D> createEntityCollection(Collection<D> arg) {
PEntityCollection<D> rv = aliasFactory.<PEntityCollection<D>> getCurrentAndReset();
return rv != null ? rv : factory.createEntityCollection(arg);
}
public <D> PEntityList<D> createEntityList(List<D> arg) {
PEntityList<D> rv = aliasFactory.<PEntityList<D>> getCurrentAndReset();
return rv != null ? rv : super.createEntityList(arg);
return rv != null ? rv : factory.createEntityList(arg);
}
public <K, V> PEntityMap<K, V> createEntityMap(Map<K, V> arg) {
PEntityMap<K, V> rv = aliasFactory.<PEntityMap<K, V>> getCurrentAndReset();
return rv != null ? rv : factory.createEntityMap(arg);
}
public <D extends Number & Comparable<?>> PNumber<D> createNumber(D arg) {
PNumber<D> rv = aliasFactory.<PNumber<D>> getCurrentAndReset();
return rv != null ? rv : factory.createNumber(arg);
}
public PString createString(String arg) {
PString rv = aliasFactory.<PString> getCurrentAndReset();
return rv != null ? rv : super.createString(arg);
return rv != null ? rv : factory.createString(arg);
}
public PStringArray createStringArray(String[] args) {
PStringArray rv = aliasFactory.<PStringArray> getCurrentAndReset();
return rv != null ? rv : super.createStringArray(args);
return rv != null ? rv : factory.createStringArray(args);
}
@SuppressWarnings("unchecked")
@Override
public <D extends Comparable> PTime<D> createTime(D arg) {
PTime<D> rv = aliasFactory.<PTime<D>>getCurrentAndReset();
return rv != null ? rv : factory.createTime(arg);
}
}

132
querydsl-core/src/main/java/com/mysema/query/alias/GrammarWithAlias.java
View File

@ -7,6 +7,8 @@ package com.mysema.query.alias;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Collection;
import java.util.List;
import java.util.Map;
@ -17,6 +19,8 @@ import com.mysema.query.types.path.PBoolean;
import com.mysema.query.types.path.PBooleanArray;
import com.mysema.query.types.path.PComparable;
import com.mysema.query.types.path.PComparableArray;
import com.mysema.query.types.path.PDate;
import com.mysema.query.types.path.PDateTime;
import com.mysema.query.types.path.PEntity;
import com.mysema.query.types.path.PEntityCollection;
import com.mysema.query.types.path.PEntityList;
@ -25,6 +29,7 @@ import com.mysema.query.types.path.PNumber;
import com.mysema.query.types.path.PSimple;
import com.mysema.query.types.path.PString;
import com.mysema.query.types.path.PStringArray;
import com.mysema.query.types.path.PTime;
import com.mysema.query.types.path.PathMetadata;
/**
@ -69,185 +74,90 @@ public class GrammarWithAlias extends Grammar {
aliasFactory.reset();
}
/**
* Convert the given alias to an expression
*
* @param arg
* @return
*/
public static PBoolean $(Boolean arg) {
return pathFactory.createBoolean(arg);
}
/**
* Convert the given alias to an expression
*
* @param <D>
* @param arg
* @return
*/
public static <D extends Comparable<?>> PComparable<D> $(D arg) {
return pathFactory.createComparable(arg);
}
/**
* Convert the given alias to an expression
*
* @param arg
* @return
*/
public static PNumber<BigDecimal> $(BigDecimal arg) {
return pathFactory.createNumber(arg);
}
/**
* Convert the given alias to an expression
*
* @param arg
* @return
*/
public static PNumber<BigInteger> $(BigInteger arg) {
return pathFactory.createNumber(arg);
}
/**
* Convert the given alias to an expression
*
* @param arg
* @return
*/
public static PNumber<Byte> $(Byte arg) {
return pathFactory.createNumber(arg);
}
/**
* Convert the given alias to an expression
*
* @param arg
* @return
*/
public static PNumber<Double> $(Double arg) {
return pathFactory.createNumber(arg);
}
/**
* Convert the given alias to an expression
*
* @param arg
* @return
*/
public static PNumber<Float> $(Float arg) {
return pathFactory.createNumber(arg);
}
/**
* Convert the given alias to an expression
*
* @param arg
* @return
*/
public static PNumber<Integer> $(Integer arg) {
return pathFactory.createNumber(arg);
}
/**
* Convert the given alias to an expression
*
* @param arg
* @return
*/
public static PNumber<Long> $(Long arg) {
return pathFactory.createNumber(arg);
}
/**
* Convert the given alias to an expression
*
* @param arg
* @return
*/
public static PNumber<Short> $(Short arg) {
return pathFactory.createNumber(arg);
}
/**
* Convert the given alias to an expression
*
* @param arg
* @return
*/
public static PString $(String arg) {
return pathFactory.createString(arg);
}
/**
* Convert the given alias to an expression
*
* @param args
* @return
*/
public static PBooleanArray $(Boolean[] args) {
return pathFactory.createBooleanArray(args);
}
/**
* Convert the given alias to an expression
*
* @param <D>
* @param args
* @return
*/
public static <D extends Comparable<?>> PComparableArray<D> $(D[] args) {
return pathFactory.createComparableArray(args);
}
/**
* Convert the given alias to an expression
*
* @param args
* @return
*/
public static PStringArray $(String[] args) {
return pathFactory.createStringArray(args);
}
/**
* Convert the given alias to an expression
*
* @param <D>
* @param args
* @return
*/
public static <D> PEntityCollection<D> $(Collection<D> args) {
return pathFactory.createEntityCollection(args);
}
public static PDateTime<java.util.Date> $(java.util.Date arg) {
return pathFactory.createDateTime(arg);
}
public static PDate<java.sql.Date> $(java.sql.Date arg) {
return pathFactory.createDate(arg);
}
public static PDateTime<Timestamp> $(Timestamp arg) {
return pathFactory.createDateTime(arg);
}
public static PTime<Time> $(Time arg) {
return pathFactory.createTime(arg);
}
/**
* Convert the given alias to an expression
*
*/
public static <K, V> PEntityMap<K, V> $(Map<K, V> args) {
return pathFactory.createEntityMap(args);
}
/**
* Convert the given alias to an expression
*
* @param <D>
* @param args
* @return
*/
public static <D> PEntityList<D> $(List<D> args) {
return pathFactory.createEntityList(args);
}
/**
* Convert the given alias to an expression
*
* @param <D>
* @param arg
* @return
*/
public static <D> PEntity<D> $(D arg) {
return pathFactory.createEntity(arg);
}

73
querydsl-core/src/main/java/com/mysema/query/alias/PathFactory.java
View File

@ -14,6 +14,8 @@ import com.mysema.query.types.path.PBoolean;
import com.mysema.query.types.path.PBooleanArray;
import com.mysema.query.types.path.PComparable;
import com.mysema.query.types.path.PComparableArray;
import com.mysema.query.types.path.PDate;
import com.mysema.query.types.path.PDateTime;
import com.mysema.query.types.path.PEntity;
import com.mysema.query.types.path.PEntityCollection;
import com.mysema.query.types.path.PEntityList;
@ -21,6 +23,7 @@ import com.mysema.query.types.path.PEntityMap;
import com.mysema.query.types.path.PNumber;
import com.mysema.query.types.path.PString;
import com.mysema.query.types.path.PStringArray;
import com.mysema.query.types.path.PTime;
/**
* PathFactory creates path expressions for domain type instances
@ -30,89 +33,37 @@ import com.mysema.query.types.path.PStringArray;
*/
interface PathFactory {
/**
*
* @param <D>
* @param arg
* @return
*/
<D> Expr<D> createAny(D arg);
/**
*
* @param arg
* @return
*/
PBoolean createBoolean(Boolean arg);
/**
*
* @param args
* @return
*/
PBooleanArray createBooleanArray(Boolean[] args);
/**
*
* @param <D>
* @param arg
* @return
*/
<D extends Number & Comparable<?>> PNumber<D> createNumber(D arg);
/**
* @param <D>
* @param arg
* @return
*/
<D extends Comparable<?>> PComparable<D> createComparable(D arg);
/**
* @param <D>
* @param arg
* @return
*/
@SuppressWarnings("unchecked")
<D extends Comparable> PDate<D> createDate(D arg);
@SuppressWarnings("unchecked")
<D extends Comparable> PTime<D> createTime(D arg);
@SuppressWarnings("unchecked")
<D extends Comparable> PDateTime<D> createDateTime(D arg);
<D> PEntity<D> createEntity(D arg);
/**
* @param <D>
* @param arg
* @return
*/
<D> PEntityList<D> createEntityList(List<D> arg);
/**
* @param <K>
* @param <V>
* @param arg
* @return
*/
<K, V> PEntityMap<K, V> createEntityMap(Map<K, V> arg);
/**
* @param <D>
* @param arg
* @return
*/
<D> PEntityCollection<D> createEntityCollection(Collection<D> arg);
/**
* @param <D>
* @param args
* @return
*/
<D extends Comparable<?>> PComparableArray<D> createComparableArray(D[] args);
/**
* @param arg
* @return
*/
PString createString(String arg);
/**
* @param args
* @return
*/
PStringArray createStringArray(String[] args);
}

20
querydsl-core/src/main/java/com/mysema/query/alias/PropertyAccessInvocationHandler.java
View File

@ -12,6 +12,7 @@ import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Timestamp;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
@ -30,6 +31,8 @@ import com.mysema.query.types.expr.EMap;
import com.mysema.query.types.expr.Expr;
import com.mysema.query.types.path.PBoolean;
import com.mysema.query.types.path.PComparable;
import com.mysema.query.types.path.PDate;
import com.mysema.query.types.path.PDateTime;
import com.mysema.query.types.path.PEntity;
import com.mysema.query.types.path.PEntityCollection;
import com.mysema.query.types.path.PEntityList;
@ -39,6 +42,7 @@ import com.mysema.query.types.path.PMap;
import com.mysema.query.types.path.PNumber;
import com.mysema.query.types.path.PSimple;
import com.mysema.query.types.path.PString;
import com.mysema.query.types.path.PTime;
import com.mysema.query.types.path.Path;
import com.mysema.query.types.path.PathMetadata;
@ -220,9 +224,21 @@ class PropertyAccessInvocationHandler implements MethodInterceptor {
path = new PNumber<Integer>(Integer.class, pm);
rv = (T) Integer.valueOf(42);
} else if (Date.class.equals(type)) {
path = new PComparable<Date>(Date.class, pm);
} else if (java.util.Date.class.equals(type)) {
path = new PDateTime<Date>(Date.class, pm);
rv = (T) new Date();
} else if (java.sql.Timestamp.class.equals(type)) {
path = new PDateTime<Timestamp>(Timestamp.class, pm);
rv = (T) new Timestamp(System.currentTimeMillis());
} else if (java.sql.Date.class.equals(type)) {
path = new PDate<java.sql.Date>(java.sql.Date.class, pm);
rv = (T) new java.sql.Date(System.currentTimeMillis());
} else if (java.sql.Time.class.equals(type)) {
path = new PTime<java.sql.Time>(java.sql.Time.class, pm);
rv = (T) new java.sql.Time(System.currentTimeMillis());
} else if (Long.class.equals(type) || long.class.equals(type)) {
path = new PNumber<Long>(Long.class, pm);

88
querydsl-core/src/main/java/com/mysema/query/alias/SimplePathFactory.java
View File

@ -20,6 +20,8 @@ import com.mysema.query.types.path.PBoolean;
import com.mysema.query.types.path.PBooleanArray;
import com.mysema.query.types.path.PComparable;
import com.mysema.query.types.path.PComparableArray;
import com.mysema.query.types.path.PDate;
import com.mysema.query.types.path.PDateTime;
import com.mysema.query.types.path.PEntity;
import com.mysema.query.types.path.PEntityCollection;
import com.mysema.query.types.path.PEntityList;
@ -27,6 +29,7 @@ import com.mysema.query.types.path.PEntityMap;
import com.mysema.query.types.path.PNumber;
import com.mysema.query.types.path.PString;
import com.mysema.query.types.path.PStringArray;
import com.mysema.query.types.path.PTime;
import com.mysema.query.types.path.PathMetadata;
/**
@ -38,6 +41,16 @@ import com.mysema.query.types.path.PathMetadata;
*/
class SimplePathFactory implements PathFactory {
private static class PathFactory<K, V> extends LazyMap<K, V> {
private static final long serialVersionUID = -2443097467085594792L;
protected PathFactory(Transformer<K, V> transformer) {
super(new WeakHashMap<K, V>(), transformer);
}
}
private final PString str = new PString(PathMetadata.forVariable("str"));
private final PBoolean btrue = new PBoolean(md()), bfalse = new PBoolean(
@ -119,6 +132,30 @@ class SimplePathFactory implements PathFactory {
return new PNumber(arg.getClass(), md());
}
});
private final Map<Object, PDate<?>> dateToPath = new PathFactory<Object, PDate<?>>(
new Transformer<Object, PDate<?>>() {
@SuppressWarnings("unchecked")
public PDate<?> transform(Object arg) {
return new PDate(arg.getClass(), md());
}
});
private final Map<Object, PDateTime<?>> dateTimeToPath = new PathFactory<Object, PDateTime<?>>(
new Transformer<Object, PDateTime<?>>() {
@SuppressWarnings("unchecked")
public PDateTime<?> transform(Object arg) {
return new PDateTime(arg.getClass(), md());
}
});
private final Map<Object, PTime<?>> timeToPath = new PathFactory<Object, PTime<?>>(
new Transformer<Object, PTime<?>>() {
@SuppressWarnings("unchecked")
public PTime<?> transform(Object arg) {
return new PTime(arg.getClass(), md());
}
});
private final Map<Object, PStringArray> saToPath = new PathFactory<Object, PStringArray>(
new Transformer<Object, PStringArray>() {
@ -155,19 +192,26 @@ class SimplePathFactory implements PathFactory {
return baToPath.get(Arrays.asList(args));
}
@SuppressWarnings("unchecked")
public <D> PEntityCollection<D> createEntityCollection(Collection<D> arg) {
return (PEntityCollection<D>) ecToPath.get(arg);
}
@SuppressWarnings("unchecked")
public <D extends Comparable<?>> PComparable<D> createComparable(D arg) {
return (PComparable<D>) comToPath.get(arg);
}
@SuppressWarnings("unchecked")
public <D extends Number & Comparable<?>> PNumber<D> createNumber(D arg) {
return (PNumber<D>) numToPath.get(arg);
public <D extends Comparable<?>> PComparableArray<D> createComparableArray(D[] args) {
return (PComparableArray<D>) caToPath.get(Arrays.asList(args));
}
@SuppressWarnings("unchecked")
@Override
public <D extends Comparable> PDate<D> createDate(D arg) {
return (PDate<D>) dateToPath.get(arg);
}
@SuppressWarnings("unchecked")
@Override
public <D extends Comparable> PDateTime<D> createDateTime(D arg) {
return (PDateTime<D>) dateTimeToPath.get(arg);
}
@SuppressWarnings("unchecked")
@ -176,9 +220,13 @@ class SimplePathFactory implements PathFactory {
}
@SuppressWarnings("unchecked")
public <D extends Comparable<?>> PComparableArray<D> createComparableArray(
D[] args) {
return (PComparableArray<D>) caToPath.get(Arrays.asList(args));
public <D> PEntityCollection<D> createEntityCollection(Collection<D> arg) {
return (PEntityCollection<D>) ecToPath.get(arg);
}
@SuppressWarnings("unchecked")
public <D> PEntityList<D> createEntityList(List<D> arg) {
return (PEntityList<D>) elToPath.get(arg);
}
@SuppressWarnings("unchecked")
@ -187,8 +235,8 @@ class SimplePathFactory implements PathFactory {
}
@SuppressWarnings("unchecked")
public <D> PEntityList<D> createEntityList(List<D> arg) {
return (PEntityList<D>) elToPath.get(arg);
public <D extends Number & Comparable<?>> PNumber<D> createNumber(D arg) {
return (PNumber<D>) numToPath.get(arg);
}
public PString createString(String arg) {
@ -199,18 +247,14 @@ class SimplePathFactory implements PathFactory {
return saToPath.get(Arrays.asList(args));
}
@SuppressWarnings("unchecked")
@Override
public <D extends Comparable> PTime<D> createTime(D arg) {
return (PTime<D>) timeToPath.get(arg);
}
private PathMetadata<String> md() {
return PathMetadata.forVariable("v" + String.valueOf(++counter));
}
private static class PathFactory<K, V> extends LazyMap<K, V> {
private static final long serialVersionUID = -2443097467085594792L;
protected PathFactory(Transformer<K, V> transformer) {
super(new WeakHashMap<K, V>(), transformer);
}
}
}

18
querydsl-core/src/main/java/com/mysema/query/functions/DateTimeFunctions.java
View File

@ -7,11 +7,11 @@ package com.mysema.query.functions;
import java.util.Date;
import com.mysema.query.types.OperationFactory;
import com.mysema.query.types.SimpleOperationFactory;
import com.mysema.query.types.expr.EComparable;
import com.mysema.query.types.expr.ENumber;
import com.mysema.query.types.expr.Expr;
import com.mysema.query.types.operation.OComparable;
import com.mysema.query.types.operation.ONumber;
import com.mysema.query.types.operation.Ops;
/**
@ -25,30 +25,28 @@ public final class DateTimeFunctions {
private DateTimeFunctions() {
}
private static final OperationFactory factory = SimpleOperationFactory.getInstance();
public static EComparable<Date> currentDate() {
return factory.createComparable(Date.class, Ops.DateTimeOps.CURRENT_DATE);
return OComparable.create(Date.class, Ops.DateTimeOps.CURRENT_DATE);
}
public static EComparable<Date> currentTime() {
return factory.createComparable(Date.class, Ops.DateTimeOps.CURRENT_TIME);
return OComparable.create(Date.class, Ops.DateTimeOps.CURRENT_TIME);
}
public static EComparable<Date> currentTimestamp() {
return factory.createComparable(Date.class, Ops.DateTimeOps.CURRENT_TIMESTAMP);
return OComparable.create(Date.class, Ops.DateTimeOps.CURRENT_TIMESTAMP);
}
public static ENumber<Integer> dayOfWeek(Expr<?> d) {
return factory.createNumber(Integer.class, Ops.DateTimeOps.DAY_OF_WEEK,d);
return ONumber.create(Integer.class, Ops.DateTimeOps.DAY_OF_WEEK,d);
}
public static ENumber<Integer> dayOfYear(Expr<?> d) {
return factory.createNumber(Integer.class, Ops.DateTimeOps.DAY_OF_YEAR,d);
return ONumber.create(Integer.class, Ops.DateTimeOps.DAY_OF_YEAR,d);
}
public static ENumber<Integer> week(Expr<?> d) {
return factory.createNumber(Integer.class, Ops.DateTimeOps.WEEK, d);
return ONumber.create(Integer.class, Ops.DateTimeOps.WEEK, d);
}

62
querydsl-core/src/main/java/com/mysema/query/functions/MathFunctions.java
View File

@ -5,12 +5,10 @@
*/
package com.mysema.query.functions;
import com.mysema.query.types.ExprFactory;
import com.mysema.query.types.OperationFactory;
import com.mysema.query.types.SimpleExprFactory;
import com.mysema.query.types.SimpleOperationFactory;
import com.mysema.query.types.expr.EConstant;
import com.mysema.query.types.expr.ENumber;
import com.mysema.query.types.expr.Expr;
import com.mysema.query.types.operation.ONumber;
import com.mysema.query.types.operation.Ops;
import com.mysema.query.types.operation.Ops.MathOps;
@ -25,112 +23,108 @@ public final class MathFunctions {
private MathFunctions() {
}
private static final OperationFactory factory = SimpleOperationFactory.getInstance();
private static final ExprFactory exprFactory = SimpleExprFactory.getInstance();
public static <A extends Number & Comparable<?>> ENumber<A> mult(Expr<A> left, A right) {
return factory.createNumber(left.getType(), Ops.MULT, left, exprFactory.createConstant(right));
return ONumber.create(left.getType(), Ops.MULT, left, EConstant.create(right));
}
public static <A extends Number & Comparable<?>> ENumber<A> mult(Expr<A> left, Expr<A> right) {
return factory.createNumber(left.getType(), Ops.MULT, left, right);
return ONumber.create(left.getType(), Ops.MULT, left, right);
}
public static <A extends Number & Comparable<?>> ENumber<Double> div(ENumber<A> left, A right) {
return factory.createNumber(Double.class, Ops.DIV, left, exprFactory.createConstant(right));
return ONumber.create(Double.class, Ops.DIV, left, EConstant.create(right));
}
public static <A extends Number & Comparable<?>> ENumber<Double> div(Expr<A> left, Expr<A> right) {
return factory.createNumber(Double.class, Ops.DIV, left, right);
return ONumber.create(Double.class, Ops.DIV, left, right);
}
public static <A extends Number & Comparable<?>> ENumber<A> add(Expr<A> left, A right) {
return factory.createNumber(left.getType(), Ops.ADD, left, exprFactory.createConstant(right));
return ONumber.create(left.getType(), Ops.ADD, left, EConstant.create(right));
}
public static <A extends Number & Comparable<?>> ENumber<A> add(Expr<A> left, Expr<A> right) {
return factory.createNumber(left.getType(), Ops.ADD, left, right);
return ONumber.create(left.getType(), Ops.ADD, left, right);
}
public static <A extends Number & Comparable<?>> ENumber<A> sub(Expr<A> left, A right) {
return factory.createNumber(left.getType(), Ops.SUB, left, exprFactory.createConstant(right));
return ONumber.create(left.getType(), Ops.SUB, left, EConstant.create(right));
}
public static <A extends Number & Comparable<?>> ENumber<A> sub(Expr<A> left, Expr<A> right) {
return factory.createNumber(left.getType(), Ops.SUB, left, right);
return ONumber.create(left.getType(), Ops.SUB, left, right);
}
public static <A extends Number & Comparable<?>> ENumber<A> abs(Expr<A> left) {
return factory.createNumber(left.getType(), MathOps.ABS, left);
return ONumber.create(left.getType(), MathOps.ABS, left);
}
public static ENumber<Double> acos(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.ACOS, left);
return ONumber.create(left.getType(), MathOps.ACOS, left);
}
public static ENumber<Double> asin(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.ASIN, left);
return ONumber.create(left.getType(), MathOps.ASIN, left);
}
public static ENumber<Double> atan(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.ATAN, left);
return ONumber.create(left.getType(), MathOps.ATAN, left);
}
public static ENumber<Double> ceil(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.CEIL, left);
return ONumber.create(left.getType(), MathOps.CEIL, left);
}
public static ENumber<Double> cos(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.COS, left);
return ONumber.create(left.getType(), MathOps.COS, left);
}
public static ENumber<Double> exp(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.EXP, left);
return ONumber.create(left.getType(), MathOps.EXP, left);
}
public static ENumber<Double> floor(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.FLOOR, left);
return ONumber.create(left.getType(), MathOps.FLOOR, left);
}
public static ENumber<Double> log(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.LOG, left);
return ONumber.create(left.getType(), MathOps.LOG, left);
}
public static ENumber<Double> log10(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.LOG10, left);
return ONumber.create(left.getType(), MathOps.LOG10, left);
}
public static <A extends Number & Comparable<?>> ENumber<A> max(Expr<A> left, Expr<A> right) {
return factory.createNumber(left.getType(), MathOps.MAX, left, right);
return ONumber.create(left.getType(), MathOps.MAX, left, right);
}
public static <A extends Number & Comparable<?>> ENumber<A> min(Expr<A> left, Expr<A> right) {
return factory.createNumber(left.getType(), MathOps.MIN, left, right);
return ONumber.create(left.getType(), MathOps.MIN, left, right);
}
public static ENumber<Double> pow(Expr<Double> left, Expr<Double> right) {
return factory.createNumber(left.getType(), MathOps.POWER, left, right);
return ONumber.create(left.getType(), MathOps.POWER, left, right);
}
public static ENumber<Double> random() {
return factory.createNumber(Double.class, MathOps.RANDOM);
return ONumber.create(Double.class, MathOps.RANDOM);
}
public static ENumber<Double> round(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.ROUND, left);
return ONumber.create(left.getType(), MathOps.ROUND, left);
}
public static ENumber<Double> sin(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.SIN, left);
return ONumber.create(left.getType(), MathOps.SIN, left);
}
public static <A extends Number & Comparable<?>> ENumber<Double> sqrt(Expr<A> left) {
return factory.createNumber(Double.class, MathOps.SQRT, left);
return ONumber.create(Double.class, MathOps.SQRT, left);
}
public static ENumber<Double> tan(Expr<Double> left) {
return factory.createNumber(left.getType(), MathOps.TAN, left);
return ONumber.create(left.getType(), MathOps.TAN, left);
}
}

34
querydsl-core/src/main/java/com/mysema/query/functions/StringFunctions.java
View File

@ -5,13 +5,13 @@
*/
package com.mysema.query.functions;
import com.mysema.query.types.ExprFactory;
import com.mysema.query.types.OperationFactory;
import com.mysema.query.types.SimpleExprFactory;
import com.mysema.query.types.SimpleOperationFactory;
import com.mysema.query.types.expr.EConstant;
import com.mysema.query.types.expr.ENumber;
import com.mysema.query.types.expr.EString;
import com.mysema.query.types.expr.Expr;
import com.mysema.query.types.operation.ONumber;
import com.mysema.query.types.operation.OSimple;
import com.mysema.query.types.operation.OString;
import com.mysema.query.types.operation.Ops;
/**
@ -25,22 +25,16 @@ public final class StringFunctions {
private StringFunctions() {
}
private static final OperationFactory factory = SimpleOperationFactory
.getInstance();
private static final ExprFactory exprFactory = SimpleExprFactory
.getInstance();
public static EString ltrim(Expr<String> s) {
return factory.createString(Ops.StringOps.LTRIM, s);
return new OString(Ops.StringOps.LTRIM, s);
}
public static EString rtrim(Expr<String> s) {
return factory.createString(Ops.StringOps.RTRIM, s);
return new OString(Ops.StringOps.RTRIM, s);
}
public static EString space(int i) {
return factory.createString(Ops.StringOps.SPACE, exprFactory.createConstant(i));
return new OString(Ops.StringOps.SPACE, EConstant.create(i));
}
/**
@ -53,9 +47,9 @@ public final class StringFunctions {
*/
public static ENumber<Integer> lastIndex(Expr<String> left, String right,
int third) {
return factory.createNumber(Integer.class,
Ops.StringOps.LAST_INDEX_2ARGS, left, exprFactory.createConstant(right),
exprFactory.createConstant(third));
return ONumber.create(Integer.class,
Ops.StringOps.LAST_INDEX_2ARGS, left, EConstant.create(right),
EConstant.create(third));
}
/**
@ -67,7 +61,7 @@ public final class StringFunctions {
*/
public static ENumber<Integer> lastIndexOf(Expr<String> left,
Expr<String> right) {
return factory.createNumber(Integer.class, Ops.StringOps.LAST_INDEX, left, right);
return ONumber.create(Integer.class, Ops.StringOps.LAST_INDEX, left, right);
}
/**
@ -78,8 +72,8 @@ public final class StringFunctions {
* @return
*/
public static ENumber<Integer> lastIndexOf(Expr<String> left, String right) {
return factory.createNumber(Integer.class, Ops.StringOps.LAST_INDEX,
left, exprFactory.createConstant(right));
return ONumber.create(Integer.class, Ops.StringOps.LAST_INDEX,
left, EConstant.create(right));
}
@ -91,7 +85,7 @@ public final class StringFunctions {
* @return
*/
public static Expr<String[]> split(Expr<String> left, String regex) {
return factory.createStringArray(Ops.StringOps.SPLIT, left, exprFactory.createConstant(regex));
return new OSimple<String,String[]>(String[].class, Ops.StringOps.SPLIT, left, EConstant.create(regex));
}
}

45
querydsl-core/src/main/java/com/mysema/query/types/ExprFactory.java
View File

@ -1,45 +0,0 @@
/*
* Copyright (c) 2009 Mysema Ltd.
* All rights reserved.
*
*/
package com.mysema.query.types;
import com.mysema.query.types.expr.Expr;
/**
* ExprFactory is a factory interface for EConstant instance creation
*
* @author tiwe
* @version $Id$
*/
public interface ExprFactory {
/**
* Create a constant for the given integer
*
*
* @param i
* @return
*/
Expr<Integer> createConstant(int i);
/**
* Create a constant for the given class
*
* @param <A>
* @param obj
* @return
*/
<A> Expr<Class<A>> createConstant(Class<A> obj);
/**
* Create a constant for the given object
*
* @param <A>
* @param obj
* @return
*/
<A> Expr<A> createConstant(A obj);
}

17
querydsl-core/src/main/java/com/mysema/query/types/Grammar.java
View File

@ -7,6 +7,7 @@ package com.mysema.query.types;
import com.mysema.query.types.expr.ENumber;
import com.mysema.query.types.expr.Expr;
import com.mysema.query.types.operation.ONumber;
import com.mysema.query.types.operation.Ops;
/**
@ -17,32 +18,28 @@ import com.mysema.query.types.operation.Ops;
*/
public class Grammar {
protected static final ExprFactory exprFactory = SimpleExprFactory.getInstance();
protected static final OperationFactory operationFactory = SimpleOperationFactory.getInstance();
public static <A extends Number & Comparable<?>> ENumber<Double> avg( Expr<A> left) {
return operationFactory.createNumber(Double.class, Ops.AVG_AGG, left);
return ONumber.create(Double.class, Ops.AVG_AGG, left);
}
public static ENumber<Long> count() {
return operationFactory.createNumber(Long.class, Ops.COUNT_ALL_AGG);
return ONumber.create(Long.class, Ops.COUNT_ALL_AGG);
}
public static ENumber<Long> count(Expr<?> expr) {
return operationFactory.createNumber(Long.class, Ops.COUNT_AGG, expr);
return ONumber.create(Long.class, Ops.COUNT_AGG, expr);
}
public static <A extends Number & Comparable<?>> ENumber<A> max( Expr<A> left) {
return operationFactory.createNumber(left.getType(), Ops.MAX_AGG, left);
return ONumber.create((Class<A>)left.getType(), Ops.MAX_AGG, left);
}
public static <A extends Number & Comparable<?>> ENumber<A> min( Expr<A> left) {
return operationFactory.createNumber(left.getType(), Ops.MIN_AGG, left);
return ONumber.create((Class<A>)left.getType(), Ops.MIN_AGG, left);
}
public static <A extends Number & Comparable<?>> ENumber<Double> sum( Expr<A> left) {
return operationFactory.createNumber(Double.class, Ops.SUM_AGG, left);
return ONumber.create(Double.class, Ops.SUM_AGG, left);
}
protected Grammar() {}

35
querydsl-core/src/main/java/com/mysema/query/types/OperationFactory.java
View File

@ -1,35 +0,0 @@
/*
* Copyright (c) 2009 Mysema Ltd.
* All rights reserved.
*
*/
package com.mysema.query.types;
import com.mysema.query.types.expr.EBoolean;
import com.mysema.query.types.expr.EComparable;
import com.mysema.query.types.expr.ENumber;
import com.mysema.query.types.expr.EString;
import com.mysema.query.types.expr.Expr;
import com.mysema.query.types.operation.Operator;
/**
* OperationFactory is a factory interface for operation expression creation
*
* @author tiwe
*
*/
public interface OperationFactory {
EBoolean createBoolean(Operator<Boolean> operator, Expr<?>... args);
<OpType, RT extends Comparable<?>> EComparable<RT> createComparable(
Class<RT> type, Operator<OpType> operator, Expr<?>... args);
<OpType extends Number, D extends Number & Comparable<?>> ENumber<D> createNumber(
Class<? extends D> type, Operator<OpType> operator, Expr<?>... args);
EString createString(Operator<String> operator, Expr<?>... args);
Expr<String[]> createStringArray(Operator<String> operator, Expr<?>... args);
}

68
querydsl-core/src/main/java/com/mysema/query/types/SimpleExprFactory.java
View File

@ -1,68 +0,0 @@
/*
* Copyright (c) 2009 Mysema Ltd.
* All rights reserved.
*
*/
package com.mysema.query.types;
import java.util.HashMap;
import java.util.Map;
import com.mysema.commons.lang.Assert;
import com.mysema.query.types.expr.EConstant;
import com.mysema.query.types.expr.Expr;
/**
* SimpleExprFactory is the default implementation of the ExprFactory interface
*
* @author tiwe
* @version $Id$
*/
public class SimpleExprFactory implements ExprFactory {
private static final ExprFactory instance = new SimpleExprFactory();
private final Map<Class<?>, Expr<?>> classToExpr = new HashMap<Class<?>, Expr<?>>();
@SuppressWarnings("unchecked")
private final Expr<Integer>[] integers = new Expr[256];
SimpleExprFactory() {
for (int i = 0; i < integers.length; i++) {
integers[i] = new EConstant<Integer>(i - 128);
}
}
public static ExprFactory getInstance() {
return instance;
}
@SuppressWarnings("unchecked")
public <A> Expr<A> createConstant(A obj) {
if (obj instanceof Expr) {
return (Expr<A>) obj;
} else {
return new EConstant<A>(Assert.notNull(obj));
}
}
@SuppressWarnings("unchecked")
public <A> Expr<Class<A>> createConstant(Class<A> obj) {
if (classToExpr.containsKey(obj)) {
return (Expr<Class<A>>) classToExpr.get(obj);
} else {
Expr<Class<A>> expr = new EConstant<Class<A>>(obj);
classToExpr.put(obj, expr);
return expr;
}
}
public Expr<Integer> createConstant(int i) {
if (i >= -128 && i <= 127) {
return integers[i + 128];
} else {
return new EConstant<Integer>(i);
}
}
}

58
querydsl-core/src/main/java/com/mysema/query/types/SimpleOperationFactory.java
View File

@ -1,58 +0,0 @@
/*
* Copyright (c) 2009 Mysema Ltd.
* All rights reserved.
*
*/
package com.mysema.query.types;
import com.mysema.commons.lang.Assert;
import com.mysema.query.types.expr.EBoolean;
import com.mysema.query.types.expr.EComparable;
import com.mysema.query.types.expr.ENumber;
import com.mysema.query.types.expr.EString;
import com.mysema.query.types.expr.Expr;
import com.mysema.query.types.operation.OBoolean;
import com.mysema.query.types.operation.OComparable;
import com.mysema.query.types.operation.ONumber;
import com.mysema.query.types.operation.OString;
import com.mysema.query.types.operation.OStringArray;
import com.mysema.query.types.operation.Operator;
/**
* SimpleOperationFactory is the default implementation of the OperationFactory itnerfa
*
* @author tiwe
*
*/
public class SimpleOperationFactory implements OperationFactory {
private static final OperationFactory instance = new SimpleOperationFactory();
public static OperationFactory getInstance() {
return instance;
}
public EBoolean createBoolean(Operator<Boolean> operator, Expr<?>... args) {
return new OBoolean(Assert.notNull(operator), Assert.notNull(args));
}
public <OpType, RT extends Comparable<?>> EComparable<RT> createComparable(
Class<RT> type, Operator<OpType> operator, Expr<?>... args) {
return new OComparable<OpType, RT>(type, Assert.notNull(operator),
Assert.notNull(args));
}
public <OpType extends Number, D extends Number & Comparable<?>> ENumber<D> createNumber(
Class<? extends D> type, Operator<OpType> operator, Expr<?>... args) {
return new ONumber<OpType, D>(type, Assert.notNull(operator), Assert
.notNull(args));
}
public EString createString(Operator<String> operator, Expr<?>... args) {
return new OString(Assert.notNull(operator), Assert.notNull(args));
}
public Expr<String[]> createStringArray(Operator<String> operator,Expr<?>... args) {
return new OStringArray(Assert.notNull(operator), Assert.notNull(args));
}
}

58
querydsl-core/src/main/java/com/mysema/query/types/expr/EConstant.java
View File

@ -5,6 +5,9 @@
*/
package com.mysema.query.types.expr;
import java.util.HashMap;
import java.util.Map;
/**
* EConstant represents constant expressions
*
@ -12,15 +15,55 @@ package com.mysema.query.types.expr;
*
* @param <D> Java type of constant
*/
public class EConstant<D> extends Expr<D> {
@SuppressWarnings("unchecked")
private static final EConstant<Integer>[] integers = new EConstant[256];
private static final Map<Class<?>, Expr<?>> classToExpr = new HashMap<Class<?>, Expr<?>>();
static{
for (int i = 0; i < integers.length; i++) {
integers[i] = new EConstant<Integer>(i - 128);
}
}
public static <A> Expr<Class<A>> create(Class<A> obj) {
if (classToExpr.containsKey(obj)) {
return (Expr<Class<A>>) classToExpr.get(obj);
} else {
Expr<Class<A>> expr = new EConstant<Class<A>>(obj);
classToExpr.put(obj, expr);
return expr;
}
}
public static <D> Expr<D> create(D val){
return new EConstant<D>(val);
}
public static Expr<Integer> create(int i){
if (i >= -128 && i <= 127) {
return integers[i + 128];
} else {
return new EConstant<Integer>(i);
}
}
private final D constant;
@SuppressWarnings("unchecked")
public EConstant(D constant) {
EConstant(D constant) {
super((Class<D>) constant.getClass());
this.constant = constant;
}
@Override
public boolean equals(Object o) {
return o instanceof EConstant ? ((EConstant<?>) o).getConstant().equals(constant) : false;
}
/**
* Get the embedded constant
*
@ -29,19 +72,10 @@ public class EConstant<D> extends Expr<D> {
public D getConstant() {
return constant;
}
@Override
public int hashCode() {
return constant.hashCode();
}
@Override
public boolean equals(Object o) {
return o instanceof EConstant ? ((EConstant<?>) o).getConstant()
.equals(constant) : false;
}
public static <D> EConstant<D> create(D val){
return new EConstant<D>(val);
}
}

2
querydsl-core/src/main/java/com/mysema/query/types/operation/OBoolean.java
View File

@ -34,7 +34,7 @@ public class OBoolean extends EBoolean implements Operation<Boolean, Boolean> {
@Override
public EBoolean not() {
if (op == Ops.NOT){
if (op == Ops.NOT && args.get(0) instanceof EBoolean){
return (EBoolean) args.get(0);
}else{
return super.not();

2
querydsl-core/src/main/java/com/mysema/query/types/operation/ONumber.java
View File

@ -51,7 +51,7 @@ public class ONumber<OpType extends Number, D extends Number & Comparable<?>>
return op;
}
public static <O extends Number,D extends Number & Comparable<?>> ENumber<D> create(Class<D> type, Operator<O> op, Expr<?>... args){
public static <O extends Number,D extends Number & Comparable<?>> ENumber<D> create(Class<? extends D> type, Operator<O> op, Expr<?>... args){
return new ONumber<O,D>(type, op, args);
}
}

15
querydsl-core/src/main/java/com/mysema/query/types/path/PathMetadata.java
View File

@ -8,8 +8,7 @@ package com.mysema.query.types.path;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import com.mysema.query.types.ExprFactory;
import com.mysema.query.types.SimpleExprFactory;
import com.mysema.query.types.expr.EConstant;
import com.mysema.query.types.expr.Expr;
/**
@ -20,8 +19,6 @@ import com.mysema.query.types.expr.Expr;
*/
public final class PathMetadata<T> {
private static ExprFactory factory = SimpleExprFactory.getInstance();
/**
* Create a new PathMetadata instance for indexed array access
*
@ -41,7 +38,7 @@ public final class PathMetadata<T> {
* @return
*/
public static PathMetadata<Integer> forArrayAccess(PArray<?> parent, int index) {
return new PathMetadata<Integer>(parent, factory.createConstant(index), PathType.ARRAYVALUE_CONSTANT);
return new PathMetadata<Integer>(parent, EConstant.create(index), PathType.ARRAYVALUE_CONSTANT);
}
/**
@ -63,7 +60,7 @@ public final class PathMetadata<T> {
* @return
*/
public static PathMetadata<Integer> forListAccess(PList<?> parent, int index) {
return new PathMetadata<Integer>(parent, factory.createConstant(index), PathType.LISTVALUE_CONSTANT);
return new PathMetadata<Integer>(parent, EConstant.create(index), PathType.LISTVALUE_CONSTANT);
}
/**
@ -87,7 +84,7 @@ public final class PathMetadata<T> {
* @return
*/
public static <KT> PathMetadata<KT> forMapAccess(PMap<?, ?> parent, KT key) {
return new PathMetadata<KT>(parent, factory.createConstant(key), PathType.MAPVALUE_CONSTANT);
return new PathMetadata<KT>(parent,EConstant.create(key), PathType.MAPVALUE_CONSTANT);
}
/**
@ -98,7 +95,7 @@ public final class PathMetadata<T> {
* @return
*/
public static PathMetadata<String> forProperty(Path<?> parent, String property) {
return new PathMetadata<String>(parent, factory.createConstant(property), PathType.PROPERTY);
return new PathMetadata<String>(parent, EConstant.create(property), PathType.PROPERTY);
}
/**
@ -108,7 +105,7 @@ public final class PathMetadata<T> {
* @return
*/
public static PathMetadata<String> forVariable(String variable) {
return new PathMetadata<String>(null, factory.createConstant(variable), PathType.VARIABLE);
return new PathMetadata<String>(null, EConstant.create(variable), PathType.VARIABLE);
}
private final Expr<T> expression;

3
querydsl-hql/src/main/java/com/mysema/query/hql/HQLGrammar.java
View File

@ -13,6 +13,7 @@ import com.mysema.query.types.expr.ENumber;
import com.mysema.query.types.expr.Expr;
import com.mysema.query.types.operation.OBoolean;
import com.mysema.query.types.operation.OComparable;
import com.mysema.query.types.operation.ONumber;
import com.mysema.query.types.operation.OSimple;
import com.mysema.query.types.operation.Ops;
@ -71,7 +72,7 @@ public class HQLGrammar extends GrammarWithAlias {
}else if (type.equals(Float.class)){
type = Double.class;
}
return operationFactory.createNumber((Class<D>) type, Ops.SUM_AGG, left);
return ONumber.create((Class<D>) type, Ops.SUM_AGG, left);
}
public static <D extends Number & Comparable<? super D>> ENumber<Long> sumAsLong(Expr<D> left) {

10
querydsl-hql/src/main/java/com/mysema/query/hql/HQLSerializer.java
View File

@ -190,7 +190,7 @@ public class HQLSerializer extends BaseSerializer<HQLSerializer> {
//
if (operator.equals(Ops.INSTANCEOF)) {
args = new ArrayList<Expr<?>>(args);
args.set(1, new EConstant<String>(((Class<?>) ((EConstant<?>) args
args.set(1, EConstant.create(((Class<?>) ((EConstant<?>) args
.get(1)).getConstant()).getName()));
super.visitOperation(type, operator, args);
@ -201,7 +201,7 @@ public class HQLSerializer extends BaseSerializer<HQLSerializer> {
args = new ArrayList<Expr<?>>(args);
if (args.get(1) instanceof EConstant){
int arg1 = ((EConstant<Integer>)args.get(1)).getConstant();
args.set(1, new EConstant<Integer>(arg1 + 1));
args.set(1, EConstant.create(arg1 + 1));
}else{
throw new IllegalArgumentException("Unsupported substr variant");
}
@ -212,8 +212,8 @@ public class HQLSerializer extends BaseSerializer<HQLSerializer> {
if (args.get(2) instanceof EConstant){
int arg1 = ((EConstant<Integer>)args.get(1)).getConstant();
int arg2 = ((EConstant<Integer>)args.get(2)).getConstant();
args.set(1, new EConstant<Integer>(arg1 + 1));
args.set(2, new EConstant<Integer>(arg2 - arg1));
args.set(1, EConstant.create(arg1 + 1));
args.set(2, EConstant.create(arg2 - arg1));
}else{
throw new IllegalArgumentException("Unsupported substr variant");
}
@ -222,7 +222,7 @@ public class HQLSerializer extends BaseSerializer<HQLSerializer> {
} else if (operator.equals(Ops.MATCHES)){
args = new ArrayList<Expr<?>>(args);
if (args.get(1) instanceof EConstant){
args.set(1, new EConstant<String>(args.get(1).toString().replace(".*", "%").replace(".", "_")));
args.set(1, EConstant.create(args.get(1).toString().replace(".*", "%").replace(".", "_")));
}
super.visitOperation(type, operator, args);

5
querydsl-sql/src/main/java/com/mysema/query/sql/SQLGrammar.java
View File

@ -7,6 +7,7 @@ package com.mysema.query.sql;
import com.mysema.query.types.Grammar;
import com.mysema.query.types.expr.EBoolean;
import com.mysema.query.types.operation.OBoolean;
import com.mysema.query.types.operation.Ops;
import com.mysema.query.types.query.ListSubQuery;
import com.mysema.query.types.query.ObjectSubQuery;
@ -20,11 +21,11 @@ import com.mysema.query.types.query.ObjectSubQuery;
public class SQLGrammar extends Grammar {
public static EBoolean exists(ObjectSubQuery<?> sq) {
return operationFactory.createBoolean(Ops.EXISTS, sq);
return new OBoolean(Ops.EXISTS, sq);
}
public static EBoolean exists(ListSubQuery<?> sq) {
return operationFactory.createBoolean(Ops.EXISTS, sq);
return new OBoolean(Ops.EXISTS, sq);
}
}

8
querydsl-sql/src/test/java/com/mysema/query/sql/HsqldbFunctionsTest.java
View File

@ -5,12 +5,8 @@
*/
package com.mysema.query.sql;
import java.sql.Time;
import java.util.Date;
import org.junit.Test;
import com.mysema.query.functions.DateTimeFunctions;
import com.mysema.query.functions.MathFunctions;
import com.mysema.query.functions.StringFunctions;
import com.mysema.query.sql.domain.QEMPLOYEE;
@ -28,8 +24,8 @@ public class HsqldbFunctionsTest {
@Test
public void testNumeric() {
Expr<Integer> i = new EConstant<Integer>(1);
Expr<Double> d = new EConstant<Double>(1.0);
Expr<Integer> i = EConstant.create(1);
Expr<Double> d = EConstant.create(1.0);
// ABS(d) returns the absolute value of a double value
MathFunctions.abs(i);
// ACOS(d) returns the arc cosine of an angle

6
querydsl-sql/src/test/java/com/mysema/query/sql/SqlQueryTest.java
View File

@ -321,7 +321,7 @@ public abstract class SqlQueryTest {
@Test
@ExcludeIn( { "hsqldb", "derby" })
public void testQueryWithoutFrom() throws SQLException {
q().list(add(new EConstant<Integer>(1), 1));
q().list(add(EConstant.create(1), 1));
}
@Test
@ -334,8 +334,8 @@ public abstract class SqlQueryTest {
@Test
@ExcludeIn( { "derby" })
public void testMathFunctions() throws SQLException {
Expr<Integer> i = new EConstant<Integer>(1);
Expr<Double> d = new EConstant<Double>(1.0);
Expr<Integer> i = EConstant.create(1);
Expr<Double> d = EConstant.create(1.0);
for (Expr<?> e : Arrays.<Expr<?>> asList(MathFunctions.abs(i),
MathFunctions.acos(d), MathFunctions.asin(d), MathFunctions
.atan(d), MathFunctions.ceil(d), MathFunctions.cos(d),