From 032b0d85934554e2bcb08b7b4ae69a9053fbf36b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timo=20Westk=C3=A4mper?= Date: Mon, 25 Feb 2008 19:38:37 +0000 Subject: [PATCH] refactored count and constructor to querydsl-hibernate made HqlSerializer use String.format templates instead of operator string + operator position --- src/main/java/com/mysema/query/ExtQuery.java | 12 +- .../java/com/mysema/query/ExtQueryBase.java | 20 +-- src/main/java/com/mysema/query/Query.java | 16 +-- src/main/java/com/mysema/query/QueryBase.java | 38 +++--- .../com/mysema/query/grammar/Grammar.java | 122 +++++++++--------- .../java/com/mysema/query/grammar/Ops.java | 3 +- .../java/com/mysema/query/grammar/Types.java | 100 +++++++------- .../com/mysema/query/grammar/Visitor.java | 22 ++-- .../mysema/query/grammar/VisitorAdapter.java | 14 +- 9 files changed, 176 insertions(+), 171 deletions(-) diff --git a/src/main/java/com/mysema/query/ExtQuery.java b/src/main/java/com/mysema/query/ExtQuery.java index 85a13363e..8bbca39af 100644 --- a/src/main/java/com/mysema/query/ExtQuery.java +++ b/src/main/java/com/mysema/query/ExtQuery.java @@ -5,8 +5,8 @@ */ package com.mysema.query; -import com.mysema.query.grammar.Types.ExprForBoolean; -import com.mysema.query.grammar.Types.ExprForEntity; +import com.mysema.query.grammar.Types.ExprBoolean; +import com.mysema.query.grammar.Types.ExprEntity; /** * ExtQuery externds the Query interface to provide innerJoin, leftJoin and with methods @@ -15,8 +15,8 @@ import com.mysema.query.grammar.Types.ExprForEntity; * @version $Id$ */ public interface ExtQuery> extends Query { - A innerJoin(ExprForEntity object); - A join(ExprForEntity object); - A leftJoin(ExprForEntity object); - A with(ExprForBoolean... objects); + A innerJoin(ExprEntity o); + A join(ExprEntity o); + A leftJoin(ExprEntity o); + A with(ExprBoolean... o); } diff --git a/src/main/java/com/mysema/query/ExtQueryBase.java b/src/main/java/com/mysema/query/ExtQueryBase.java index b06f3ba88..006f3e77d 100644 --- a/src/main/java/com/mysema/query/ExtQueryBase.java +++ b/src/main/java/com/mysema/query/ExtQueryBase.java @@ -5,8 +5,8 @@ */ package com.mysema.query; -import com.mysema.query.grammar.Types.ExprForBoolean; -import com.mysema.query.grammar.Types.ExprForEntity; +import com.mysema.query.grammar.Types.ExprBoolean; +import com.mysema.query.grammar.Types.ExprEntity; /** * ExtQueryBased provides a basic implementation of the ExtQuery interface @@ -17,24 +17,24 @@ import com.mysema.query.grammar.Types.ExprForEntity; @SuppressWarnings("unchecked") public class ExtQueryBase> extends QueryBase implements ExtQuery { - public A innerJoin(ExprForEntity object) { - joins.add(new JoinExpression(JoinType.IJ,object)); + public A innerJoin(ExprEntity o) { + joins.add(new JoinExpression(JoinType.IJ,o)); return (A) this; } - public A join(ExprForEntity object) { - joins.add(new JoinExpression(JoinType.J,object)); + public A join(ExprEntity o) { + joins.add(new JoinExpression(JoinType.J,o)); return (A) this; } - public A leftJoin(ExprForEntity object) { - joins.add(new JoinExpression(JoinType.LJ,object)); + public A leftJoin(ExprEntity o) { + joins.add(new JoinExpression(JoinType.LJ,o)); return (A) this; } - public A with(ExprForBoolean... objects) { + public A with(ExprBoolean... o) { if (!joins.isEmpty()){ - joins.get(joins.size()-1).conditions = objects; + joins.get(joins.size()-1).conditions = o; } return (A) this; } diff --git a/src/main/java/com/mysema/query/Query.java b/src/main/java/com/mysema/query/Query.java index 2a7eea3c9..7e87ee707 100644 --- a/src/main/java/com/mysema/query/Query.java +++ b/src/main/java/com/mysema/query/Query.java @@ -5,8 +5,8 @@ */ package com.mysema.query; -import com.mysema.query.grammar.Types.ExprForBoolean; -import com.mysema.query.grammar.Types.ExprForEntity; +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; @@ -17,10 +17,10 @@ import com.mysema.query.grammar.Types.OrderSpecifier; * @version $Id$ */ public interface Query>{ - A select(Expr... objects); - A from(ExprForEntity... objects); - A where(ExprForBoolean... objects); - A groupBy(Expr... objects); - A having(ExprForBoolean... objects); - A orderBy(OrderSpecifier... objects); + A select(Expr... o); + A from(ExprEntity... o); + A where(ExprBoolean... o); + A groupBy(Expr... o); + A having(ExprBoolean... o); + A orderBy(OrderSpecifier... o); } \ No newline at end of file diff --git a/src/main/java/com/mysema/query/QueryBase.java b/src/main/java/com/mysema/query/QueryBase.java index c7853ef15..c16b0e564 100644 --- a/src/main/java/com/mysema/query/QueryBase.java +++ b/src/main/java/com/mysema/query/QueryBase.java @@ -8,8 +8,8 @@ package com.mysema.query; import java.util.ArrayList; import java.util.List; -import com.mysema.query.grammar.Types.ExprForBoolean; -import com.mysema.query.grammar.Types.ExprForEntity; +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; /** @@ -26,20 +26,20 @@ public class QueryBase> implements Query { public class JoinExpression{ public final JoinType type; - public final ExprForEntity target; - JoinExpression(JoinType type, ExprForEntity target){ + public final ExprEntity target; + JoinExpression(JoinType type, ExprEntity target){ this.type = type; this.target = target; } - public ExprForBoolean[] conditions; + public ExprBoolean[] conditions; } protected List joins = new ArrayList(); protected Expr[] groupBy; - protected ExprForBoolean[] having; + protected ExprBoolean[] having; protected OrderSpecifier[] orderBy; protected Expr[] select; - protected ExprForBoolean[] where; + protected ExprBoolean[] where; protected void clear(){ joins.clear(); @@ -50,36 +50,36 @@ public class QueryBase> implements Query { where = null; } - public A from(ExprForEntity... objects) { - for (ExprForEntity expr : objects){ + public A from(ExprEntity... o) { + for (ExprEntity expr : o){ joins.add(new JoinExpression(JoinType.DEFAULT,expr)); } return (A) this; } - public A groupBy(Expr... objects) { - groupBy = objects; + public A groupBy(Expr... o) { + groupBy = o; return (A) this; } - public A having(ExprForBoolean... objects) { - having = objects; + public A having(ExprBoolean... o) { + having = o; return (A) this; } - public A orderBy(OrderSpecifier... objects) { - orderBy = objects; + public A orderBy(OrderSpecifier... o) { + orderBy = o; return (A) this; } - public A select(Expr... objects) { - select = objects; + public A select(Expr... o) { + select = o; return (A) this; } - public A where(ExprForBoolean... objects) { - where = objects; + public A where(ExprBoolean... o) { + where = o; return (A) this; } diff --git a/src/main/java/com/mysema/query/grammar/Grammar.java b/src/main/java/com/mysema/query/grammar/Grammar.java index f5b6eede8..462980986 100644 --- a/src/main/java/com/mysema/query/grammar/Grammar.java +++ b/src/main/java/com/mysema/query/grammar/Grammar.java @@ -5,8 +5,10 @@ */ package com.mysema.query.grammar; -import com.mysema.query.grammar.Types.*; +import java.util.Collection; + import com.mysema.query.grammar.Ops.*; +import com.mysema.query.grammar.Types.*; /** * Grammar provides the factory methods for the fluent grammar @@ -16,7 +18,7 @@ import com.mysema.query.grammar.Ops.*; */ public class Grammar { - static ExprForBoolean _binOp(Op operator, Expr left, + static ExprBoolean _binOp(Op operator, Expr left, Expr right) { OperationBinaryBoolean op = new OperationBinaryBoolean(); op.operator = operator; @@ -57,7 +59,7 @@ public class Grammar { return os; } - static ExprForBoolean _terOp(Op type, Expr fst, + static ExprBoolean _terOp(Op type, Expr fst, Expr snd, Expr trd) { OperationTertiaryBoolean op = new OperationTertiaryBoolean(); op.operator = type; @@ -77,7 +79,7 @@ public class Grammar { return op; } - static ExprForBoolean _unOp(Op type, Expr left) { + static ExprBoolean _unOp(Op type, Expr left) { OperationUnaryBoolean op = new OperationUnaryBoolean(); op.operator = type; op.left = left; @@ -91,15 +93,15 @@ public class Grammar { return op; } - public static ExprForNoEntity add(Expr left, A right) { + public static ExprNoEntity add(Expr left, A right) { return _binOp(OpNumber.ADD, left, _const(right)); } - public static ExprForNoEntity add(Expr left, Expr right) { + public static ExprNoEntity add(Expr left, Expr right) { return _binOp(OpNumber.ADD, left, right); } - public static > ExprForBoolean after(Expr left, + public static > ExprBoolean after(Expr left, A right) { // NOTE : signature is for Comparables to support other than Java's date // types @@ -107,7 +109,7 @@ public class Grammar { return _binOp(OpDate.AFTER, left, _const(right)); } - public static > ExprForBoolean after(Expr left, + public static > ExprBoolean after(Expr left, Expr right) { // NOTE : signature is for Comparables to support other than Java's date // types @@ -115,28 +117,28 @@ public class Grammar { return _binOp(OpDate.AFTER, left, right); } - public static ExprForBoolean and(ExprForBoolean left, ExprForBoolean right) { + public static ExprBoolean and(ExprBoolean left, ExprBoolean right) { return _binOp(OpBoolean.AND, left, right); } - public static AliasForCollection as(PathForEntityCollection from, PathForEntity to) { - return new AliasForCollection(from, to); - } - - public static AliasForEntity as(PathForEntity from, PathForEntity to) { - return new AliasForEntity(from, to); - } - - public static AliasForNoEntity as(ExprForNoEntity from, String to) { + public static AliasNoEntity as(ExprNoEntity from, String to) { // NOTE : maybe this needs to be possible for all expressions - return new AliasForNoEntity(from, to); + return new AliasNoEntity(from, to); + } + + public static AliasEntity as(PathEntity from, PathEntity to) { + return new AliasEntity(from, to); + } + + public static AliasCollection as(PathEntityCollection from, PathEntity to) { + return new AliasCollection(from, to); } public static > OrderSpecifier asc(Expr target) { return _orderAsc(target); } - public static > ExprForBoolean before(Expr left, + public static > ExprBoolean before(Expr left, A right) { // NOTE : signature is for Comparables to support other than Java's date // types @@ -144,7 +146,7 @@ public class Grammar { return _binOp(OpDate.BEFORE, left, _const(right)); } - public static > ExprForBoolean before(Expr left, + public static > ExprBoolean before(Expr left, Expr right) { // NOTE : signature is for Comparables to support other than Java's date // types @@ -152,150 +154,154 @@ public class Grammar { return _binOp(OpDate.BEFORE, left, right); } - public static > ExprForBoolean between(Expr left, + public static > ExprBoolean between(Expr left, A start, A end) { return _terOp(OpComparable.BETWEEN, left, _const(start), _const(end)); } - public static > ExprForBoolean between(Expr left, + public static > ExprBoolean between(Expr left, Expr start, Expr end) { return _terOp(OpComparable.BETWEEN, left, start, end); } - public static ExprForNoEntity concat(Expr left, Expr right) { + public static ExprNoEntity concat(Expr left, Expr right) { return _binOp(OpString.CONCAT, left, right); } - - public static ExprForNoEntity count(){ - return new CountExpr(); - } public static > OrderSpecifier desc( Expr target) { return _orderDesc(target); } - public static ExprForNoEntity div(Expr left, A right) { + public static ExprNoEntity div(Expr left, A right) { return _binOp(OpNumber.DIV, left, _const(right)); } - public static ExprForNoEntity div(Expr left, Expr right) { + public static ExprNoEntity div(Expr left, Expr right) { return _binOp(OpNumber.DIV, left, right); } - public static ExprForBoolean eq(Expr left, B right) { + public static ExprBoolean eq(Expr left, B right) { return _binOp(Op.EQ, left, _const(right)); } - public static ExprForBoolean eq(Expr left, Expr right) { + public static ExprBoolean eq(Expr left, Expr right) { return _binOp(Op.EQ, left, right); } - public static > ExprForBoolean goe(Expr left, + public static > ExprBoolean goe(Expr left, A right) { return _binOp(OpNumber.GOE, left, _const(right)); } - public static > ExprForBoolean goe(Expr left, + public static > ExprBoolean goe(Expr left, Expr right) { return _binOp(OpNumber.GOE, left, right); } - public static > ExprForBoolean gt(Expr left, A right) { + public static > ExprBoolean gt(Expr left, A right) { return _binOp(OpNumber.GT, left, _const(right)); } - public static > ExprForBoolean gt(Expr left, + public static > ExprBoolean gt(Expr left, Expr right) { return _binOp(OpNumber.GT, left, right); } - public static > ExprForBoolean in(Expr left, + public static ExprBoolean in(A left, ExprEntity> right){ + return _binOp(Op.INELEMENTS, _const(left), right); + } + + public static > ExprBoolean in(Expr left, A... rest) { - return _binOp(Op.IN, left, _const(rest)); + return _binOp(Op.INARRAY, left, _const(rest)); + } + + public static ExprBoolean in(ExprEntity left, ExprEntity> right){ + return _binOp(Op.INELEMENTS, left, right); } - public static ExprForBoolean isnotnull(Expr left) { + public static ExprBoolean isnotnull(Expr left) { return _unOp(Op.ISNOTNULL, left); } - public static ExprForBoolean isnull(Expr left) { + public static ExprBoolean isnull(Expr left) { return _unOp(Op.ISNULL, left); } - public static ExprForBoolean like(Expr left, String right) { + public static ExprBoolean like(Expr left, String right) { return _binOp(OpString.LIKE, left, _const(right)); } - public static > ExprForBoolean loe(Expr left, + public static > ExprBoolean loe(Expr left, A right) { return _binOp(OpNumber.LOE, left, _const(right)); } - public static > ExprForBoolean loe(Expr left, + public static > ExprBoolean loe(Expr left, Expr right) { return _binOp(OpNumber.LOE, left, right); } - public static ExprForNoEntity lower(Expr left) { + public static ExprNoEntity lower(Expr left) { return _unOp(OpString.LOWER, left); } - public static > ExprForBoolean lt(Expr left, A right) { + public static > ExprBoolean lt(Expr left, A right) { return _binOp(OpNumber.LT, left, _const(right)); } - public static > ExprForBoolean lt(Expr left, + public static > ExprBoolean lt(Expr left, Expr right) { return _binOp(OpNumber.LT, left, right); } - public static ExprForNoEntity mult(Expr left, A right) { + public static ExprNoEntity mult(Expr left, A right) { return _binOp(OpNumber.MULT, left, _const(right)); } - public static ExprForNoEntity mult(Expr left, Expr right) { + public static ExprNoEntity mult(Expr left, Expr right) { return _binOp(OpNumber.MULT, left, right); } - public static ExprForBoolean ne(Expr left, B right) { + public static ExprBoolean ne(Expr left, B right) { return _binOp(Op.NE, left, _const(right)); } - public static ExprForBoolean ne(Expr left, Expr right) { + public static ExprBoolean ne(Expr left, Expr right) { return _binOp(Op.NE, left, right); } - public static ExprForBoolean not(ExprForBoolean left) { + public static ExprBoolean not(ExprBoolean left) { return _unOp(OpBoolean.NOT, left); } - public static ExprForBoolean or(ExprForBoolean left, ExprForBoolean right) { + public static ExprBoolean or(ExprBoolean left, ExprBoolean right) { return _binOp(OpBoolean.OR, left, right); } - public static ExprForNoEntity sub(Expr left, A right) { + public static ExprNoEntity sub(Expr left, A right) { return _binOp(OpNumber.SUB, left, _const(right)); } - public static ExprForNoEntity sub(Expr left, Expr right) { + public static ExprNoEntity sub(Expr left, Expr right) { return _binOp(OpNumber.SUB, left, right); } - public static ExprForNoEntity substr(Expr left, int start) { + public static ExprNoEntity substr(Expr left, int start) { return _binOp(OpString.SUBSTR, left, _const(start)); } - public static ExprForNoEntity substr(Expr left, int start, int offset) { + public static ExprNoEntity substr(Expr left, int start, int offset) { return _terOp(OpString.SUBSTR, left, _const(start), _const(offset)); } - public static ExprForBoolean typeOf(Expr left, + public static ExprBoolean typeOf(Expr left, Class right) { return _binOp(Op.ISTYPEOF, left, _const(right)); } - public static ExprForNoEntity upper(Expr left) { + public static ExprNoEntity upper(Expr left) { return _unOp(OpString.UPPER, left); } } diff --git a/src/main/java/com/mysema/query/grammar/Ops.java b/src/main/java/com/mysema/query/grammar/Ops.java index 8d5fe8aff..05be2ea75 100644 --- a/src/main/java/com/mysema/query/grammar/Ops.java +++ b/src/main/java/com/mysema/query/grammar/Ops.java @@ -18,7 +18,8 @@ public class Ops { */ public interface Op { Op EQ = new OpImpl(); - Op IN = new OpImpl(); + Op INARRAY = new OpImpl(); + Op INELEMENTS = new OpImpl(); Op ISNOTNULL = new OpImpl(); Op ISNULL = new OpImpl(); Op ISTYPEOF = new OpImpl(); diff --git a/src/main/java/com/mysema/query/grammar/Types.java b/src/main/java/com/mysema/query/grammar/Types.java index 731bb796b..6ff71c0d9 100644 --- a/src/main/java/com/mysema/query/grammar/Types.java +++ b/src/main/java/com/mysema/query/grammar/Types.java @@ -18,7 +18,7 @@ import com.mysema.query.grammar.Ops.Op; */ public class Types { - public abstract static class Alias extends ExprImpl{ + public abstract static class Alias extends ExprNonFinalImpl{ public final Expr from; public final String to; Alias(Expr from, String to) { @@ -27,23 +27,23 @@ public class Types { } } - public static class AliasForCollection extends Alias implements ExprForEntity{ - AliasForCollection(PathForEntityCollection from, Path to) { + public static class AliasCollection extends Alias implements ExprEntity{ + AliasCollection(PathEntityCollection from, Path to) { super(from,to.toString()); } } - public static class AliasForEntity extends Alias implements ExprForEntity{ - AliasForEntity(PathForEntity from, PathForEntity to) { + public static class AliasEntity extends Alias implements ExprEntity{ + AliasEntity(PathEntity from, PathEntity to) { super(from,to.toString()); } - AliasForEntity(PathForEntity from, String to) { + AliasEntity(PathEntity from, String to) { super(from,to); } } - public static class AliasForNoEntity extends Alias implements ExprForNoEntity{ - AliasForNoEntity(Expr from, String to) { + public static class AliasNoEntity extends Alias implements ExprNoEntity{ + AliasNoEntity(Expr from, String to) { super(from,to); } public Expr as(String to) { @@ -51,44 +51,44 @@ public class Types { } } - public static class ConstantExpr extends ExprImpl{ + public static class ConstantExpr extends ExprNonFinalImpl{ public D constant; } - public static class CountExpr extends ExprForNoEntityImpl{ - // TODO : move to querydsl-hibernate + public interface Expr { + } - public interface Expr { - public ExprForBoolean eq(B right); - public ExprForBoolean eq(Expr right); - public ExprForBoolean ne(B right); - public ExprForBoolean ne(Expr right); + public interface ExprNonFinal extends Expr { + public ExprBoolean eq(B right); + public ExprBoolean eq(Expr right); + public ExprBoolean ne(B right); + public ExprBoolean ne(Expr right); } - static abstract class ExprImpl implements Expr{ - public ExprForBoolean eq(B right){return Grammar.eq(this, right);} - public ExprForBoolean eq(Expr right){return Grammar.eq(this, right);} - public ExprForBoolean ne(B right){return Grammar.ne(this, right);} - public ExprForBoolean ne(Expr right){return Grammar.ne(this, right);} - } - - public interface ExprForBoolean extends ExprForNoEntity{ } + public interface ExprBoolean extends ExprNoEntity{ } /** * Reference to an entity */ - public interface ExprForEntity extends Expr{} + public interface ExprEntity extends Expr{} + + static abstract class ExprNonFinalImpl implements ExprNonFinal{ + public ExprBoolean eq(B right){return Grammar.eq(this, right);} + public ExprBoolean eq(Expr right){return Grammar.eq(this, right);} + public ExprBoolean ne(B right){return Grammar.ne(this, right);} + public ExprBoolean ne(Expr right){return Grammar.ne(this, right);} + } - public interface ExprForNoEntity extends Expr{ + public interface ExprNoEntity extends ExprNonFinal{ public Expr as(String to); } - static abstract class ExprForNoEntityImpl extends ExprImpl implements ExprForNoEntity{ + public static abstract class ExprNoEntityImpl extends ExprNonFinalImpl implements ExprNoEntity{ public Expr as(String to){return Grammar.as(this, to);} } - public abstract static class Operation extends ExprForNoEntityImpl { + public abstract static class Operation extends ExprNoEntityImpl { public Expr as(String to) { return Grammar.as(this, to); } @@ -104,7 +104,7 @@ public class Types { } public static class OperationBinaryBoolean extends OperationBinary - implements ExprForBoolean { + implements ExprBoolean { public Expr as(String to) { return Grammar.as(this, to); } @@ -121,7 +121,7 @@ public class Types { } public static class OperationTertiaryBoolean extends OperationTertiary - implements ExprForBoolean{ + implements ExprBoolean{ } public static class OperationUnary extends Operation{ @@ -133,7 +133,7 @@ public class Types { } public static class OperationUnaryBoolean extends OperationUnary - implements ExprForBoolean{ + implements ExprBoolean{ } public enum Order{ ASC,DESC } @@ -143,7 +143,7 @@ public class Types { public Expr target; } - public abstract static class Path extends ExprImpl{ + public abstract static class Path extends ExprNonFinalImpl{ // path is hidden to not pollute the namespace of the domain types private final String path; public Path(String p) { @@ -153,40 +153,40 @@ public class Types { public final String toString(){ return path; } } - public static class PathForBoolean extends PathForNoEntity implements ExprForBoolean{ - PathForBoolean(String path) {super(path);} + public static class PathBoolean extends PathNoEntity implements ExprBoolean{ + PathBoolean(String path) {super(path);} } - public static class PathForEntity extends Path implements ExprForEntity{ - protected PathForEntity(PathForEntity type, String path) { + public static class PathEntity extends Path implements ExprEntity{ + protected PathEntity(PathEntity type, String path) { super(type+"."+path); } - protected PathForEntity(String path) {super(path);} - protected PathForBoolean _boolean(String path){ - return new PathForBoolean(this+"."+path); + protected PathEntity(String path) {super(path);} + protected PathBoolean _boolean(String path){ + return new PathBoolean(this+"."+path); } - protected PathForEntityCollection _collection(String path,Class type) { - return new PathForEntityCollection(this+"."+path); + protected PathEntityCollection _collection(String path,Class type) { + return new PathEntityCollection(this+"."+path); } - protected PathForNoEntity _prop(String path,Class type) { - return new PathForNoEntity(this+"."+path); + protected PathNoEntity _prop(String path,Class type) { + return new PathNoEntity(this+"."+path); } - public AliasForEntity as(PathForEntity to) {return Grammar.as(this, to);} + public AliasEntity as(PathEntity to) {return Grammar.as(this, to);} } - public static class PathForEntityCollection extends Path> implements - ExprForEntity>{ - PathForEntityCollection(String p) { + public static class PathEntityCollection extends Path> implements + ExprEntity>{ + PathEntityCollection(String p) { super(p); } - public AliasForCollection as(PathForEntity to) { + public AliasCollection as(PathEntity to) { return Grammar.as(this, to); } } - public static class PathForNoEntity extends Path implements ExprForNoEntity{ - public PathForNoEntity(String p) { + public static class PathNoEntity extends Path implements ExprNoEntity{ + public PathNoEntity(String p) { super(p); } public Expr as(String to) { diff --git a/src/main/java/com/mysema/query/grammar/Visitor.java b/src/main/java/com/mysema/query/grammar/Visitor.java index d5c6846c8..4ca073aed 100644 --- a/src/main/java/com/mysema/query/grammar/Visitor.java +++ b/src/main/java/com/mysema/query/grammar/Visitor.java @@ -22,10 +22,10 @@ public abstract class Visitor> { @Override protected Method create(Class cl) { - while (!Types.class.equals(cl.getEnclosingClass())){ - cl = cl.getSuperclass(); - } try { + if (PathEntity.class.isAssignableFrom(cl)){ + cl = PathEntity.class; + } Method method = null; Class sigClass = Visitor.this.getClass(); while (method == null && !sigClass.equals(Visitor.class)){ @@ -60,16 +60,14 @@ public abstract class Visitor> { protected abstract void visit(Alias expr); - protected abstract void visit(AliasForNoEntity expr); + protected abstract void visit(AliasNoEntity expr); - protected abstract void visit(AliasForCollection expr); + protected abstract void visit(AliasCollection expr); - protected abstract void visit(AliasForEntity expr); + protected abstract void visit(AliasEntity expr); protected abstract void visit(ConstantExpr expr); - protected abstract void visit(CountExpr expr); - protected abstract void visit(OperationBinary expr); protected abstract void visit(OperationBinaryBoolean expr); @@ -84,12 +82,12 @@ public abstract class Visitor> { protected abstract void visit(Path expr); - protected abstract void visit(PathForBoolean expr); + protected abstract void visit(PathBoolean expr); - protected abstract void visit(PathForEntityCollection expr); + protected abstract void visit(PathEntityCollection expr); - protected abstract void visit(PathForEntity expr); + protected abstract void visit(PathEntity expr); - protected abstract void visit(PathForNoEntity expr); + protected abstract void visit(PathNoEntity expr); } diff --git a/src/main/java/com/mysema/query/grammar/VisitorAdapter.java b/src/main/java/com/mysema/query/grammar/VisitorAdapter.java index 66b9d8417..206958101 100644 --- a/src/main/java/com/mysema/query/grammar/VisitorAdapter.java +++ b/src/main/java/com/mysema/query/grammar/VisitorAdapter.java @@ -17,17 +17,17 @@ import com.mysema.query.grammar.Types.*; public abstract class VisitorAdapter> extends Visitor{ @Override - protected void visit(AliasForNoEntity expr) { + protected void visit(AliasNoEntity expr) { visit((Alias)expr); } @Override - protected void visit(AliasForCollection expr){ + protected void visit(AliasCollection expr){ visit((Alias)expr); } @Override - protected void visit(AliasForEntity expr) { + protected void visit(AliasEntity expr) { visit((Alias)expr); } @@ -37,22 +37,22 @@ public abstract class VisitorAdapter> extends Visito } @Override - protected void visit(PathForBoolean expr) { + protected void visit(PathBoolean expr) { visit((Path)expr); } @Override - protected void visit(PathForEntityCollection expr){ + protected void visit(PathEntityCollection expr){ visit((Path)expr); } @Override - protected void visit(PathForEntity expr) { + protected void visit(PathEntity expr) { visit((Path)expr); } @Override - protected void visit(PathForNoEntity expr) { + protected void visit(PathNoEntity expr) { visit((Path)expr); }