diff --git a/querydsl-core/src/main/java/com/mysema/query/JoinExpression.java b/querydsl-core/src/main/java/com/mysema/query/JoinExpression.java
new file mode 100644
index 000000000..3a8f3a71e
--- /dev/null
+++ b/querydsl-core/src/main/java/com/mysema/query/JoinExpression.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2008 Mysema Ltd.
+ * All rights reserved.
+ * 
+ */
+package com.mysema.query;
+
+import com.mysema.query.grammar.Types.ExprBoolean;
+import com.mysema.query.grammar.Types.ExprEntity;
+
+public class JoinExpression {
+    public ExprBoolean[] conditions;
+    public final ExprEntity<?> target;
+    public final JoinType type;
+    JoinExpression(JoinType type, ExprEntity<?> target) {
+        this.type = type;
+        this.target = target;
+    }
+}
\ No newline at end of file
diff --git a/querydsl-core/src/main/java/com/mysema/query/JoinType.java b/querydsl-core/src/main/java/com/mysema/query/JoinType.java
new file mode 100644
index 000000000..5c7f5491f
--- /dev/null
+++ b/querydsl-core/src/main/java/com/mysema/query/JoinType.java
@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2008 Mysema Ltd.
+ * All rights reserved.
+ * 
+ */
+package com.mysema.query;
+
+public enum JoinType {
+    DEFAULT, IJ, J, LJ
+}
\ No newline at end of file
diff --git a/querydsl-core/src/main/java/com/mysema/query/Query.java b/querydsl-core/src/main/java/com/mysema/query/Query.java
index b2b842402..2d80cb8d4 100644
--- a/querydsl-core/src/main/java/com/mysema/query/Query.java
+++ b/querydsl-core/src/main/java/com/mysema/query/Query.java
@@ -8,7 +8,7 @@ package com.mysema.query;
 import com.mysema.query.grammar.Types.ExprBoolean;
 import com.mysema.query.grammar.Types.ExprEntity;
 import com.mysema.query.grammar.Types.Expr;
-import com.mysema.query.grammar.Types.OrderSpecifier;
+import com.mysema.query.grammar.OrderSpecifier;
 
 /**
  * Query provides a the query interface of the fluent query DSL
diff --git a/querydsl-core/src/main/java/com/mysema/query/QueryBase.java b/querydsl-core/src/main/java/com/mysema/query/QueryBase.java
index 2db8af24b..99a032936 100644
--- a/querydsl-core/src/main/java/com/mysema/query/QueryBase.java
+++ b/querydsl-core/src/main/java/com/mysema/query/QueryBase.java
@@ -12,7 +12,7 @@ import java.util.List;
 import com.mysema.query.grammar.Types.Expr;
 import com.mysema.query.grammar.Types.ExprBoolean;
 import com.mysema.query.grammar.Types.ExprEntity;
-import com.mysema.query.grammar.Types.OrderSpecifier;
+import com.mysema.query.grammar.OrderSpecifier;
 /**
  * QueryBase provides a basic implementation of the Query interface
  *
@@ -53,17 +53,18 @@ public class QueryBase<A extends QueryBase<A>> implements Query<A> {
         having.addAll(Arrays.asList(o));
         return (A) this;
     }
-    @Deprecated
+    
+    @Deprecated 
     public A innerJoin(ExprEntity<?> o) {
         joins.add(new JoinExpression(JoinType.IJ,o));
         return (A) this;
     }
-    @Deprecated
+    @Deprecated 
     public A join(ExprEntity<?> o) {
         joins.add(new JoinExpression(JoinType.J,o));
         return (A) this;
     }
-    @Deprecated
+    @Deprecated 
     public A leftJoin(ExprEntity<?> o) {
         joins.add(new JoinExpression(JoinType.LJ,o));
         return (A) this;
@@ -83,27 +84,12 @@ public class QueryBase<A extends QueryBase<A>> implements Query<A> {
         where.addAll(Arrays.asList(o));
         return (A) this;
     }
-
-    @Deprecated
+    @Deprecated 
     public A with(ExprBoolean... o) {
         if (!joins.isEmpty()){
             joins.get(joins.size()-1).conditions = o;
         }
         return (A) this;
     }
-
-    public static class JoinExpression{
-        public ExprBoolean[] conditions;
-        public final ExprEntity<?> target;
-        public final JoinType type;
-        JoinExpression(JoinType type, ExprEntity<?> target){
-            this.type = type;
-            this.target = target;
-        }
-    }
-    
-    public enum JoinType{
-        DEFAULT,IJ,J,LJ
-    }
     
 }
diff --git a/querydsl-core/src/main/java/com/mysema/query/grammar/Grammar.java b/querydsl-core/src/main/java/com/mysema/query/grammar/Grammar.java
index 470d35f03..73c5e4725 100644
--- a/querydsl-core/src/main/java/com/mysema/query/grammar/Grammar.java
+++ b/querydsl-core/src/main/java/com/mysema/query/grammar/Grammar.java
@@ -107,10 +107,10 @@ public class Grammar {
         return new AliasEntity<D>(from, to);
     }
     
-    static <D> AliasCollection<D> as(PathEntityCollection<D> from, PathEntity<D> to) {
+    static <D> AliasEntityCollection<D> as(PathEntityCollection<D> from, PathEntity<D> to) {
         _check("from",from);
         _check("to",to);
-        return new AliasCollection<D>(from, to);
+        return new AliasEntityCollection<D>(from, to);
     }
 
     static <A extends Comparable<A>> OrderSpecifier<A> asc(Expr<A> target) {
@@ -141,10 +141,14 @@ public class Grammar {
         return _boolean(OpComparable.BETWEEN, left, start, end);
     }
 
-    public static ExprNoEntity<String> concat(Expr<String> left, Expr<String> right) {
+    static ExprString concat(Expr<String> left, Expr<String> right) {
         return _string(OpString.CONCAT, left, right);
     }
     
+    static ExprString concat(Expr<String> left, String right) {
+        return _string(OpString.CONCAT, left, _const(right));
+    }
+    
     static <A extends Comparable<A>> OrderSpecifier<A> desc(
             Expr<A> target) {
         return _orderDesc(target);
@@ -166,21 +170,21 @@ public class Grammar {
         return _boolean(Op.EQ, left, right);
     }
 
-    public static <A extends Comparable<A>> ExprBoolean goe(Expr<A> left,
+    static <A extends Comparable<A>> ExprBoolean goe(Expr<A> left,
             A right) {
         return _boolean(OpComparable.GOE, left, _const(right));
     }
 
-    public static <A extends Comparable<A>> ExprBoolean goe(Expr<A> left,
+    static <A extends Comparable<A>> ExprBoolean goe(Expr<A> left,
             Expr<A> right) {
         return _boolean(OpComparable.GOE, left, right);
     }
 
-    public static <A extends Comparable<A>> ExprBoolean gt(Expr<A> left, A right) {
+    static <A extends Comparable<A>> ExprBoolean gt(Expr<A> left, A right) {
         return _boolean(OpComparable.GT, left, _const(right));
     }
 
-    public static <A extends Comparable<A>> ExprBoolean gt(Expr<A> left,
+    static <A extends Comparable<A>> ExprBoolean gt(Expr<A> left,
             Expr<A> right) {
         return _boolean(OpComparable.GT, left, right);
     }
@@ -256,7 +260,11 @@ public class Grammar {
     static ExprBoolean or(ExprBoolean left, ExprBoolean right) {
         return _boolean(OpBoolean.OR, left, right);
     }
-
+    
+    public static <A> SubQuery<A> select(Expr<A> select){
+        return new SubQuery<A>(select);
+    }
+    
     public static <A extends Comparable<A>> ExprComparable<A> sub(Expr<A> left, A right) {
         return _number(OpNumber.SUB, left, _const(right));
     }
diff --git a/querydsl-core/src/main/java/com/mysema/query/grammar/Order.java b/querydsl-core/src/main/java/com/mysema/query/grammar/Order.java
new file mode 100644
index 000000000..e07ca50c0
--- /dev/null
+++ b/querydsl-core/src/main/java/com/mysema/query/grammar/Order.java
@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2008 Mysema Ltd.
+ * All rights reserved.
+ * 
+ */
+package com.mysema.query.grammar;
+
+public enum Order {
+    ASC, DESC
+}
\ No newline at end of file
diff --git a/querydsl-core/src/main/java/com/mysema/query/grammar/OrderSpecifier.java b/querydsl-core/src/main/java/com/mysema/query/grammar/OrderSpecifier.java
new file mode 100644
index 000000000..8dbf0ac75
--- /dev/null
+++ b/querydsl-core/src/main/java/com/mysema/query/grammar/OrderSpecifier.java
@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2008 Mysema Ltd.
+ * All rights reserved.
+ * 
+ */
+package com.mysema.query.grammar;
+
+public class OrderSpecifier<A extends Comparable<A>> {
+    public Order order;
+    public Types.Expr<A> target;
+}
\ No newline at end of file
diff --git a/querydsl-core/src/main/java/com/mysema/query/grammar/Types.java b/querydsl-core/src/main/java/com/mysema/query/grammar/Types.java
index bd58a75ab..c70a21b94 100644
--- a/querydsl-core/src/main/java/com/mysema/query/grammar/Types.java
+++ b/querydsl-core/src/main/java/com/mysema/query/grammar/Types.java
@@ -5,7 +5,9 @@
  */
 package com.mysema.query.grammar;
 
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.List;
 
 import com.mysema.query.grammar.Ops.Op;
 
@@ -23,10 +25,10 @@ public class Types {
         String getTo();
     }
             
-    public static class AliasCollection<D> extends ExprEntity<D> implements Alias<D>{
+    public static class AliasEntityCollection<D> extends ExprEntity<D> implements Alias<D>{
         private final Expr<?> from;
         private final String to;
-        AliasCollection(PathEntityCollection<D> from, Path<D> to) {
+        AliasEntityCollection(PathEntityCollection<D> from, Path<D> to) {
             super(null);
             this.from = from;
             this.to = to.toString();
@@ -39,12 +41,12 @@ public class Types {
         private final Expr<?> from;
         private final String to;
         AliasEntity(PathEntity<D> from, PathEntity<D> to) {
-            super(from._type());
+            super(from.getType());
             this.from = from;
             this.to = to.toString();
         }
         AliasEntity(PathEntity<D> from, String to) {
-            super(from._type());
+            super(from.getType());
             this.from = from;
             this.to = to;
         }
@@ -80,11 +82,11 @@ public class Types {
     public static abstract class Expr<D>{
         private final Class<D> type;
         Expr(Class<D> type){this.type = type;}        
-        public <B extends D> ExprBoolean eq(B right){return Grammar.eq(this, right);}        
+        protected Class<D> getType(){ return type;}        
+        public <B extends D> ExprBoolean eq(B right){return Grammar.eq(this, right);}
         public <B extends D> ExprBoolean eq(Expr<B> right){return Grammar.eq(this, right);}
         public <B extends D> ExprBoolean ne(B right){return Grammar.ne(this, right);}
         public <B extends D> ExprBoolean ne(Expr<B> right){return Grammar.ne(this, right);}
-        protected Class<D> _type(){ return type;}
     }
     
     public static abstract class ExprBoolean extends ExprNoEntity<Boolean>{
@@ -125,6 +127,8 @@ public class Types {
         
     public static abstract class ExprString extends ExprComparable<String>{
         ExprString() {super(String.class);}
+        public ExprString concat(Expr<String> str) {return Grammar.concat(this, str);}
+        public ExprString concat(String str) {return Grammar.concat(this, str);}
         public ExprBoolean like(String str) { return Grammar.like(this, str); }
         public ExprString lower() { return Grammar.lower(this); }
         public ExprString substring(int beginIndex) { return Grammar.substring(this, beginIndex);}
@@ -178,74 +182,97 @@ public class Types {
         public Op<String> getOperator() {return op;}    
     }
     
-    public enum Order{ ASC,DESC }
-        
-    public static class OrderSpecifier<A extends Comparable<A>>{
-        public Order order; 
-        public Expr<A> target;       
+    public static final class PathMetadata{
+        private final Path<?> parent;
+        private final String localName;
+        private final String path;
+        PathMetadata(Path<?> parent, String localName){
+            this.parent = parent;
+            this.path = parent.getMetadata().path + "." + localName;
+            this.localName = localName;
+        }
+        PathMetadata(String localName) {
+            this.parent = null;
+            this.path = localName;
+            this.localName = localName;
+        }
+        public Path<?> parent(){ return parent; }
+        public String localName(){ return localName; }
+        public String path(){ return path;}
+        public String toString(){ return path; }
     }
-        
+            
     public interface Path<C>{
-        Path<?> _parent();
+        PathMetadata getMetadata();
         ExprBoolean isnotnull();
         ExprBoolean isnull();
     }
     
     public static class PathBoolean extends ExprBoolean implements PathNoEntity<Boolean>{
-        private final Path<?> parent;
-        private final  String path;
-        PathBoolean(Path<?> parent,String path) {
-            this.parent = parent;
-            this.path = parent.toString()+"."+path;
+        private final PathMetadata metadata;
+        PathBoolean(Path<?> parent,String localName) {
+            metadata = new PathMetadata(parent, localName);
         }        
-        public Path<?> _parent() {return parent;}
         public ExprBoolean isnotnull() {return Grammar.isnotnull(this);}
         public ExprBoolean isnull() {return Grammar.isnull(this);}
-        public String toString(){ return path;}        
+        public String toString(){ return metadata.path;}
+        public PathMetadata getMetadata() {return metadata;}                
     }
     
     public static class PathComparable<D extends Comparable<D>> extends ExprComparable<D> implements PathNoEntity<D>{
-        private final Path<?> parent;
-        private final String path;
-        public PathComparable(Class<D> type, Path<?> parent, String path) {
+        private final PathMetadata metadata;
+        public PathComparable(Class<D> type, Path<?> parent, String localName) {
             super(type);
-            this.parent = parent;
-            this.path = parent.toString()+"."+path;
+            metadata = new PathMetadata(parent, localName);
         }
-        public Path<?> _parent() {return parent;}
         public ExprBoolean isnotnull() {return Grammar.isnotnull(this);}
         public ExprBoolean isnull() {return Grammar.isnull(this);}
-        public String toString() {return path;}
+        public String toString() {return metadata.path;}
+        public PathMetadata getMetadata() {return metadata;}
+    }
+    
+    public static class PathComponentCollection<D> extends ExprNoEntity<Collection<D>> implements Path<Collection<D>>{
+        private final PathMetadata metadata;
+        private final Class<D> type;
+        PathComponentCollection(Class<D> type, Path<?> parent, String localName) {
+            super(null);            
+            this.type = type;
+            metadata = new PathMetadata(parent, localName);
+        }        
+        public ExprNoEntity<D> get(int index) {return new PathNoEntitySimple<D>(type, metadata.parent, metadata.localName + "["+index+"]");}
+        public ExprBoolean isnotnull() {return Grammar.isnotnull(this);}
+        public ExprBoolean isnull() {return Grammar.isnull(this);}
+        public String toString() {return metadata.path;}  
+        public PathMetadata getMetadata() {return metadata;}
     }
     
     public static class PathEntity<D> extends ExprEntity<D> implements Path<D>{
-        private final Path<?> parent;
-        private final String path;
-        protected PathEntity(Class<D> type, String path) {
+        private final PathMetadata metadata;
+        protected PathEntity(Class<D> type, Path<?> parent, String localName) {
             super(type);
-            this.parent = null;
-            this.path = path;
+            metadata = new PathMetadata(parent, localName);
         }
-        protected PathEntity(Class<D> type, Path<?> parent, String path) {
+        protected PathEntity(Class<D> type, String localName) {
             super(type);
-            this.parent = parent;
-            this.path = parent.toString()+"."+path;
+            metadata = new PathMetadata(localName);
         }
         protected PathBoolean _boolean(String path){
             return new PathBoolean(this, path);
         }
-        protected <A>PathEntityCollection<A> _collection(String path,Class<A> type) {
-            return new PathEntityCollection<A>(type, this, path);
-        }
         protected <A extends Comparable<A>> PathComparable<A> _comparable(String path,Class<A> type) {
             return new PathComparable<A>(type, this, path);
         }
         protected <A> PathEntityRenamable<A> _entity(String path, Class<A> type){
             return new PathEntityRenamable<A>(type, this, path); 
+        }        
+        protected <A>PathEntityCollection<A> _entitycol(String path,Class<A> type) {
+            return new PathEntityCollection<A>(type, this, path);
         }
-        public Path<?> _parent() {return parent;}
         protected <A> PathNoEntitySimple<A> _simple(String path, Class<A> type){
             return new PathNoEntitySimple<A>(type, this, path);
+        }
+        protected <A>PathComponentCollection<A> _simplecol(String path,Class<A> type) {
+            return new PathComponentCollection<A>(type, this, path);
         }        
         protected PathString _string(String path){
             return new PathString(this, path);
@@ -253,28 +280,25 @@ public class Types {
         public ExprBoolean in(ExprEntity<Collection<D>> right){return Grammar.in(this, right);}
         public ExprBoolean isnotnull() {return Grammar.isnotnull(this);}
         public ExprBoolean isnull() {return Grammar.isnull(this);}
-        public String toString() {return path;}
+        public String toString() {return metadata.path;}
         public <B extends D> ExprBoolean typeOf(Class<B> type) {return Grammar.typeOf(this, type);}
+        public PathMetadata getMetadata() {return metadata;}
     }
     
     public static class PathEntityCollection<D> extends ExprEntity<Collection<D>> implements Path<Collection<D>>{
-        private final Path<?> parent;
-        private final String property, path;
+        private final PathMetadata metadata;
         private final Class<D> type;
-        PathEntityCollection(Class<D> type, Path<?> parent, String path) {
+        PathEntityCollection(Class<D> type, Path<?> parent, String localName) {
             super(null);            
             this.type = type;
-            this.parent = parent;
-            this.property = path;
-            this.path = parent.toString()+"."+path;
+            metadata = new PathMetadata(parent, localName);
         }        
-        public Path<?> _parent() {return parent;}
-        public AliasCollection<D> as(PathEntity<D> to) {return Grammar.as(this, to);}
-        public ExprEntity<D> get(int index) {return new PathEntity<D>(type, _parent(), property + "["+index+"]");}
+        public AliasEntityCollection<D> as(PathEntity<D> to) {return Grammar.as(this, to);}
+        public ExprEntity<D> get(int index) {return new PathEntity<D>(type, metadata.parent, metadata.localName + "["+index+"]");}
         public ExprBoolean isnotnull() {return Grammar.isnotnull(this);}
         public ExprBoolean isnull() {return Grammar.isnull(this);}
-        public String toString() {return path;}
-        
+        public String toString() {return metadata.path;}       
+        public PathMetadata getMetadata() {return metadata;}
     }
     
     public static class PathEntityRenamable<D> extends PathEntity<D>{
@@ -287,30 +311,41 @@ public class Types {
     }
     
     public static class PathNoEntitySimple<D> extends ExprNoEntity<D> implements PathNoEntity<D>{
-        private final Path<?> parent;
-        private final String path;        
-        public PathNoEntitySimple(Class<D> type, Path<?> parent, String path) {
+        private final PathMetadata metadata;
+        public PathNoEntitySimple(Class<D> type, Path<?> parent, String localName) {
             super(type);
-            this.parent = parent;
-            this.path = parent.toString()+"."+path;
+            metadata = new PathMetadata(parent, localName);
         }
-        public Path<?> _parent() {return parent;}
         public ExprBoolean isnotnull() {return Grammar.isnotnull(this);}
         public ExprBoolean isnull() {return Grammar.isnull(this);}
-        public String toString() {return path;}
+        public String toString() {return metadata.path;}
+        public PathMetadata getMetadata() {return metadata;}
     }
     
     public static class PathString extends ExprString implements PathNoEntity<String>{
-        private final Path<?> parent;
-        private final String path;
-        public PathString(Path<?> parent, String path) {
-            this.parent = parent;
-            this.path = parent.toString()+"."+path;
+        private final PathMetadata metadata;
+        public PathString(Path<?> parent, String localName) {
+            metadata = new PathMetadata(parent, localName);
         }
-        public Path<?> _parent() {return parent;}
         public ExprBoolean isnotnull() {return Grammar.isnotnull(this);}
         public ExprBoolean isnull() {return Grammar.isnull(this);}
-        public String toString() {return path;}
+        public String toString() {return metadata.path;}
+        public PathMetadata getMetadata() {return metadata;}
+    }
+    
+    public static class SubQuery<A> extends Expr<Collection<A>>{
+        private List<ExprEntity<?>> from;
+        private final Expr<A> select;
+        private List<ExprBoolean> where;
+        SubQuery(Expr<A> select) {
+            super(null);
+            this.select = select;
+        }    
+        List<ExprEntity<?>> _from() {return from;}
+        Expr<A> _select() {return select;}
+        List<ExprBoolean> _where() {return where;}
+        public SubQuery<A> from(ExprEntity<?>... o){this.from = Arrays.asList(o); return this;}
+        public SubQuery<A> where(ExprBoolean... o){this.where = Arrays.asList(o); return this;}        
     }
     
 }
diff --git a/querydsl-core/src/main/java/com/mysema/query/grammar/Visitor.java b/querydsl-core/src/main/java/com/mysema/query/grammar/Visitor.java
index 1d35da259..2ceb1afec 100644
--- a/querydsl-core/src/main/java/com/mysema/query/grammar/Visitor.java
+++ b/querydsl-core/src/main/java/com/mysema/query/grammar/Visitor.java
@@ -62,7 +62,7 @@ public abstract class Visitor<T extends Visitor<T>> {
 
     protected abstract void visit(Alias<?> expr);
     
-    protected abstract void visit(AliasCollection<?> expr);
+    protected abstract void visit(AliasEntityCollection<?> expr);
 
     protected abstract void visit(AliasEntity<?> expr);
 
@@ -85,6 +85,8 @@ public abstract class Visitor<T extends Visitor<T>> {
     protected abstract void visit(PathBoolean expr);
 
     protected abstract void visit(PathComparable<?> expr);
+    
+    protected abstract void visit(PathComponentCollection<?> expr);
 
     protected abstract void visit(PathEntity<?> expr);
 
@@ -97,5 +99,7 @@ public abstract class Visitor<T extends Visitor<T>> {
     protected abstract void visit(PathNoEntitySimple<?> expr);
 
     protected abstract void visit(PathString expr);
+    
+    protected abstract void visit(SubQuery<?> subQuery);
 
 }
diff --git a/querydsl-core/src/main/java/com/mysema/query/grammar/VisitorAdapter.java b/querydsl-core/src/main/java/com/mysema/query/grammar/VisitorAdapter.java
index a3bc7b107..c7d5db5f9 100644
--- a/querydsl-core/src/main/java/com/mysema/query/grammar/VisitorAdapter.java
+++ b/querydsl-core/src/main/java/com/mysema/query/grammar/VisitorAdapter.java
@@ -18,7 +18,7 @@ public abstract class VisitorAdapter<V extends VisitorAdapter<V>> extends
         Visitor<V> {
 
     @Override
-    protected void visit(AliasCollection<?> expr) {
+    protected void visit(AliasEntityCollection<?> expr) {
         visit((Alias<?>) expr);
     }
     @Override
@@ -52,6 +52,10 @@ public abstract class VisitorAdapter<V extends VisitorAdapter<V>> extends
     @Override
     protected void visit(PathComparable<?> expr) {
         visit((Path<?>) expr);
+    }
+    @Override
+    protected void visit(PathComponentCollection<?> expr) {
+        visit((Path<?>) expr);
     }    
     @Override
     protected void visit(PathString expr) {