diff --git a/querydsl-collections/src/test/java/com/mysema/query/collections/AliasTest.java b/querydsl-collections/src/test/java/com/mysema/query/collections/AliasTest.java
index f73e3bd45..950d9e911 100644
--- a/querydsl-collections/src/test/java/com/mysema/query/collections/AliasTest.java
+++ b/querydsl-collections/src/test/java/com/mysema/query/collections/AliasTest.java
@@ -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
diff --git a/querydsl-collections/src/test/java/com/mysema/query/collections/MathFunctionTest.java b/querydsl-collections/src/test/java/com/mysema/query/collections/MathFunctionTest.java
index dfd5cb440..46eb44e7f 100644
--- a/querydsl-collections/src/test/java/com/mysema/query/collections/MathFunctionTest.java
+++ b/querydsl-collections/src/test/java/com/mysema/query/collections/MathFunctionTest.java
@@ -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),
diff --git a/querydsl-core/src/main/java/com/mysema/query/alias/AliasAwarePathFactory.java b/querydsl-core/src/main/java/com/mysema/query/alias/AliasAwarePathFactory.java
index 9aa1e4e7b..6d914a2c7 100644
--- a/querydsl-core/src/main/java/com/mysema/query/alias/AliasAwarePathFactory.java
+++ b/querydsl-core/src/main/java/com/mysema/query/alias/AliasAwarePathFactory.java
@@ -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);
     }
 
 }
diff --git a/querydsl-core/src/main/java/com/mysema/query/alias/GrammarWithAlias.java b/querydsl-core/src/main/java/com/mysema/query/alias/GrammarWithAlias.java
index 9722607e0..021714ea7 100644
--- a/querydsl-core/src/main/java/com/mysema/query/alias/GrammarWithAlias.java
+++ b/querydsl-core/src/main/java/com/mysema/query/alias/GrammarWithAlias.java
@@ -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);
     }
diff --git a/querydsl-core/src/main/java/com/mysema/query/alias/PathFactory.java b/querydsl-core/src/main/java/com/mysema/query/alias/PathFactory.java
index 1acaa165a..f27e15cce 100644
--- a/querydsl-core/src/main/java/com/mysema/query/alias/PathFactory.java
+++ b/querydsl-core/src/main/java/com/mysema/query/alias/PathFactory.java
@@ -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);
 
 }
\ No newline at end of file
diff --git a/querydsl-core/src/main/java/com/mysema/query/alias/PropertyAccessInvocationHandler.java b/querydsl-core/src/main/java/com/mysema/query/alias/PropertyAccessInvocationHandler.java
index 1cf73de9c..b2768c1f2 100644
--- a/querydsl-core/src/main/java/com/mysema/query/alias/PropertyAccessInvocationHandler.java
+++ b/querydsl-core/src/main/java/com/mysema/query/alias/PropertyAccessInvocationHandler.java
@@ -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);
diff --git a/querydsl-core/src/main/java/com/mysema/query/alias/SimplePathFactory.java b/querydsl-core/src/main/java/com/mysema/query/alias/SimplePathFactory.java
index 6d27e0d0b..424fef23c 100644
--- a/querydsl-core/src/main/java/com/mysema/query/alias/SimplePathFactory.java
+++ b/querydsl-core/src/main/java/com/mysema/query/alias/SimplePathFactory.java
@@ -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);
-        }
-
-    }
-
 }
diff --git a/querydsl-core/src/main/java/com/mysema/query/functions/DateTimeFunctions.java b/querydsl-core/src/main/java/com/mysema/query/functions/DateTimeFunctions.java
index 2a5881c3a..5e0542f03 100644
--- a/querydsl-core/src/main/java/com/mysema/query/functions/DateTimeFunctions.java
+++ b/querydsl-core/src/main/java/com/mysema/query/functions/DateTimeFunctions.java
@@ -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);
     }
 
 
diff --git a/querydsl-core/src/main/java/com/mysema/query/functions/MathFunctions.java b/querydsl-core/src/main/java/com/mysema/query/functions/MathFunctions.java
index d852167bf..9e50e9a73 100644
--- a/querydsl-core/src/main/java/com/mysema/query/functions/MathFunctions.java
+++ b/querydsl-core/src/main/java/com/mysema/query/functions/MathFunctions.java
@@ -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);
     }
 
 }
diff --git a/querydsl-core/src/main/java/com/mysema/query/functions/StringFunctions.java b/querydsl-core/src/main/java/com/mysema/query/functions/StringFunctions.java
index b48514cd7..128f3cda2 100644
--- a/querydsl-core/src/main/java/com/mysema/query/functions/StringFunctions.java
+++ b/querydsl-core/src/main/java/com/mysema/query/functions/StringFunctions.java
@@ -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));
     }
 
 }
diff --git a/querydsl-core/src/main/java/com/mysema/query/types/ExprFactory.java b/querydsl-core/src/main/java/com/mysema/query/types/ExprFactory.java
deleted file mode 100644
index 0c1586abf..000000000
--- a/querydsl-core/src/main/java/com/mysema/query/types/ExprFactory.java
+++ /dev/null
@@ -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);
-
-}
diff --git a/querydsl-core/src/main/java/com/mysema/query/types/Grammar.java b/querydsl-core/src/main/java/com/mysema/query/types/Grammar.java
index 82dbb5097..01f904c8d 100644
--- a/querydsl-core/src/main/java/com/mysema/query/types/Grammar.java
+++ b/querydsl-core/src/main/java/com/mysema/query/types/Grammar.java
@@ -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() {}
diff --git a/querydsl-core/src/main/java/com/mysema/query/types/OperationFactory.java b/querydsl-core/src/main/java/com/mysema/query/types/OperationFactory.java
deleted file mode 100644
index ee0c7f098..000000000
--- a/querydsl-core/src/main/java/com/mysema/query/types/OperationFactory.java
+++ /dev/null
@@ -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);
-
-}
diff --git a/querydsl-core/src/main/java/com/mysema/query/types/SimpleExprFactory.java b/querydsl-core/src/main/java/com/mysema/query/types/SimpleExprFactory.java
deleted file mode 100644
index 5cc8ebb7d..000000000
--- a/querydsl-core/src/main/java/com/mysema/query/types/SimpleExprFactory.java
+++ /dev/null
@@ -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);
-        }
-    }
-
-}
diff --git a/querydsl-core/src/main/java/com/mysema/query/types/SimpleOperationFactory.java b/querydsl-core/src/main/java/com/mysema/query/types/SimpleOperationFactory.java
deleted file mode 100644
index b9554d7fa..000000000
--- a/querydsl-core/src/main/java/com/mysema/query/types/SimpleOperationFactory.java
+++ /dev/null
@@ -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));
-    }
-}
diff --git a/querydsl-core/src/main/java/com/mysema/query/types/expr/EConstant.java b/querydsl-core/src/main/java/com/mysema/query/types/expr/EConstant.java
index be0ed1df2..4e759c0d9 100644
--- a/querydsl-core/src/main/java/com/mysema/query/types/expr/EConstant.java
+++ b/querydsl-core/src/main/java/com/mysema/query/types/expr/EConstant.java
@@ -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);
-    }
 }
\ No newline at end of file
diff --git a/querydsl-core/src/main/java/com/mysema/query/types/operation/OBoolean.java b/querydsl-core/src/main/java/com/mysema/query/types/operation/OBoolean.java
index db80bdb5a..063923825 100644
--- a/querydsl-core/src/main/java/com/mysema/query/types/operation/OBoolean.java
+++ b/querydsl-core/src/main/java/com/mysema/query/types/operation/OBoolean.java
@@ -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();
diff --git a/querydsl-core/src/main/java/com/mysema/query/types/operation/ONumber.java b/querydsl-core/src/main/java/com/mysema/query/types/operation/ONumber.java
index 2ce9d0fcd..9715585ca 100644
--- a/querydsl-core/src/main/java/com/mysema/query/types/operation/ONumber.java
+++ b/querydsl-core/src/main/java/com/mysema/query/types/operation/ONumber.java
@@ -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);
     }
 }
\ No newline at end of file
diff --git a/querydsl-core/src/main/java/com/mysema/query/types/path/PathMetadata.java b/querydsl-core/src/main/java/com/mysema/query/types/path/PathMetadata.java
index 2fe8f0bde..08d4942e1 100644
--- a/querydsl-core/src/main/java/com/mysema/query/types/path/PathMetadata.java
+++ b/querydsl-core/src/main/java/com/mysema/query/types/path/PathMetadata.java
@@ -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;
diff --git a/querydsl-hql/src/main/java/com/mysema/query/hql/HQLGrammar.java b/querydsl-hql/src/main/java/com/mysema/query/hql/HQLGrammar.java
index 7085f5318..3a9b5ea16 100644
--- a/querydsl-hql/src/main/java/com/mysema/query/hql/HQLGrammar.java
+++ b/querydsl-hql/src/main/java/com/mysema/query/hql/HQLGrammar.java
@@ -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) {
diff --git a/querydsl-hql/src/main/java/com/mysema/query/hql/HQLSerializer.java b/querydsl-hql/src/main/java/com/mysema/query/hql/HQLSerializer.java
index ac685759d..66305c204 100644
--- a/querydsl-hql/src/main/java/com/mysema/query/hql/HQLSerializer.java
+++ b/querydsl-hql/src/main/java/com/mysema/query/hql/HQLSerializer.java
@@ -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);
             
diff --git a/querydsl-sql/src/main/java/com/mysema/query/sql/SQLGrammar.java b/querydsl-sql/src/main/java/com/mysema/query/sql/SQLGrammar.java
index 12fa695cd..79d453776 100644
--- a/querydsl-sql/src/main/java/com/mysema/query/sql/SQLGrammar.java
+++ b/querydsl-sql/src/main/java/com/mysema/query/sql/SQLGrammar.java
@@ -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);
     }
     
 }
diff --git a/querydsl-sql/src/test/java/com/mysema/query/sql/HsqldbFunctionsTest.java b/querydsl-sql/src/test/java/com/mysema/query/sql/HsqldbFunctionsTest.java
index 893fdeed9..d478581be 100644
--- a/querydsl-sql/src/test/java/com/mysema/query/sql/HsqldbFunctionsTest.java
+++ b/querydsl-sql/src/test/java/com/mysema/query/sql/HsqldbFunctionsTest.java
@@ -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
diff --git a/querydsl-sql/src/test/java/com/mysema/query/sql/SqlQueryTest.java b/querydsl-sql/src/test/java/com/mysema/query/sql/SqlQueryTest.java
index e1c23077e..a0f8bb1b5 100644
--- a/querydsl-sql/src/test/java/com/mysema/query/sql/SqlQueryTest.java
+++ b/querydsl-sql/src/test/java/com/mysema/query/sql/SqlQueryTest.java
@@ -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),