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

unified handling of collections and subqueries

Browse Source
This commit is contained in:
Timo Westkämper 2008-03-17 18:00:02 +00:00
parent f6be1fe9b6
commit 0ba83e7ca7
6 changed files with 268 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
querydsl-hibernate/src/main/java/com/mysema/query/grammar/HqlGrammar.java
View File

@ -7,7 +7,11 @@ package com.mysema.query.grammar;
import java.util.Date;
import com.mysema.query.Query;
import com.mysema.query.QueryBase;
import com.mysema.query.grammar.HqlOps.OpHql;
import com.mysema.query.grammar.HqlOps.OpQuant;
import com.mysema.query.grammar.Ops.Op;
import com.mysema.query.grammar.Types.*;
/**
@ -18,10 +22,23 @@ import com.mysema.query.grammar.Types.*;
*/
public class HqlGrammar extends Grammar{
public static ExprComparable<Long> count(){
return new CountExpr(null);
public static <D> Expr<D> all(CollectionType<D> col){
return new ExprQuantSimple<D>(OpQuant.ALL, col);
}
public static <D extends Comparable<D>> ExprComparable<D> all(CollectionType<D> col){
return new ExprQuantComparable<D>(OpQuant.ALL, col);
}
public static <D> Expr<D> any(CollectionType<D> col){
return new ExprQuantSimple<D>(OpQuant.ANY, col);
}
public static <D extends Comparable<D>> ExprComparable<D> any(CollectionType<D> col){
return new ExprQuantComparable<D>(OpQuant.ANY, col);
}
public static ExprComparable<Long> count(){
return new CountExpr(null);
}
public static ExprComparable<Long> count(Expr<?> expr){
return new CountExpr(expr);
}
@ -29,28 +46,29 @@ public class HqlGrammar extends Grammar{
public static ExprComparable<Date> current_date(){
return _comparable(OpHql.CURRENT_DATE);
}
public static ExprComparable<Date> current_time(){
return _comparable(OpHql.CURRENT_TIME);
}
}
public static ExprComparable<Date> current_timestamp(){
return _comparable(OpHql.CURRENT_TIMESTAMP);
}
}
public static ExprComparable<Date> day(Expr<Date> date){
return _comparable(OpHql.DAY, date);
}
public static <T> Expr<T> distinct(PathEntity<T> left){
return new DistinctPath<T>(left);
}
}
public static <T> Expr<T> distinct(PathNoEntity<T> left){
return new DistinctPath<T>(left);
}
public static ExprBoolean exists(PathEntityCollection<?> col) {
return _boolean(OpHql.EXISTS, col);
public static <D> ExprBoolean exists(CollectionType<D> col){
return new ExprQuantBoolean<D>(OpQuant.EXISTS, col);
}
public static <A> SubQuery<A> from(ExprEntity<A> select){
return new SubQuery<A>(select).from(select);
}
public static ExprComparable<Date> hour(Expr<Date> date){
@ -59,8 +77,7 @@ public class HqlGrammar extends Grammar{
public static ExprBoolean isempty(PathEntityCollection<?> collection) {
return _boolean(OpHql.ISEMPTY, collection);
}
}
public static ExprBoolean isnotempty(PathEntityCollection<?> collection) {
return _boolean(OpHql.ISNOTEMPTY, collection);
}
@ -72,7 +89,7 @@ public class HqlGrammar extends Grammar{
public static ExprComparable<Integer> minindex(PathEntityCollection<?> collection) {
return _comparable(OpHql.MININDEX, collection);
}
public static ExprComparable<Date> minute(Expr<Date> date){
return _comparable(OpHql.MINUTE, date);
}
@ -80,13 +97,26 @@ public class HqlGrammar extends Grammar{
public static ExprComparable<Date> month(Expr<Date> date){
return _comparable(OpHql.MONTH, date);
}
public static <A> Expr<A> newInstance(Class<A> a, Expr<?>... args){
return new Constructor<A>(a,args);
}
public static <D> ExprBoolean notExists(CollectionType<D> col){
return new ExprQuantBoolean<D>(OpQuant.NOTEXISTS, col);
}
public static ExprComparable<Date> second(Expr<Date> date){
return _comparable(OpHql.SECOND, date);
}
public static <A> SubQuery<A> select(Expr<A> select){
return new SubQuery<A>(select);
}
public static <D> Expr<D> some(CollectionType<D> col){
return any(col);
}
public static <D extends Comparable<D>> ExprComparable<D> sum(Expr<D> left){
return _number(OpHql.SUM, left);
@ -120,11 +150,73 @@ public class HqlGrammar extends Grammar{
public static class DistinctPath<T> extends Expr<T>{
private final Path<T> path;
@SuppressWarnings("unchecked")
public DistinctPath(Path<T> path) {
super(((Expr<T>)path).getType());
this.path = path;
}
public Path<T> getPath(){ return path; }
}
public interface ExprQuant{
Op<?> getOperator();
Expr<?> getTarget();
}
public static class ExprQuantBoolean<Q> extends ExprBoolean implements ExprQuant{
private final Expr<?> col;
private final Op<?> op;
ExprQuantBoolean(Op<?> op, CollectionType<Q> col) {
this.op = op;
this.col = (Expr<?>) col;
}
public Op<?> getOperator() {return op;}
public Expr<?> getTarget() {return col;}
}
public static class ExprQuantComparable<Q extends Comparable<Q>> extends ExprComparable<Q> implements ExprQuant{
private final Expr<?> col;
private final Op<?> op;
ExprQuantComparable(Op<?> op, CollectionType<Q> col) {
super(null);
this.op = op;
this.col = (Expr<?>)col;
}
public Op<?> getOperator() {return op;}
public Expr<?> getTarget() {return col;}
}
public static class ExprQuantSimple<Q> extends Expr<Q> implements ExprQuant{
private final Expr<?> col;
private final Op<?> op;
ExprQuantSimple(Op<?> op, CollectionType<Q> col) {
super(null);
this.op = op;
this.col = (Expr<?>)col;
}
public Op<?> getOperator() {return op;}
public Expr<?> getTarget() {return col;}
}
public static class SubQuery<A> extends Expr<A> implements Query<SubQuery<A>>,CollectionType<A>{
@SuppressWarnings("unchecked")
private QueryBase<?> query = new QueryBase();
SubQuery(Expr<A> select) {
super(null);
query.select(select);
}
public SubQuery<A> from(ExprEntity<?>... o) {query.from(o); return this;}
public SubQuery<A> fullJoin(ExprEntity<?> o) {query.fullJoin(o); return this;}
public QueryBase<?> getQuery(){ return query;}
public SubQuery<A> groupBy(Expr<?>... o) {query.groupBy(o); return this;}
public SubQuery<A> having(ExprBoolean... o) {query.having(o); return this;}
public SubQuery<A> innerJoin(ExprEntity<?> o) {query.innerJoin(o); return this;}
public SubQuery<A> join(ExprEntity<?> o) {query.join(o); return this;}
public SubQuery<A> leftJoin(ExprEntity<?> o) {query.leftJoin(o); return this;}
public SubQuery<A> orderBy(OrderSpecifier<?>... o) {query.orderBy(o); return this;}
public SubQuery<A> select(Expr<?>... o) {query.select(o); return this;}
public SubQuery<A> where(ExprBoolean... o) {query.where(o); return this;}
public SubQuery<A> with(ExprBoolean... o) {query.with(o); return this;}
}
}

28
querydsl-hibernate/src/main/java/com/mysema/query/grammar/HqlOps.java
View File

@ -56,9 +56,8 @@ public class HqlOps extends Ops {
add(Op.EQ, "%s = %s",18);
add(Op.ISTYPEOF, "%s.class = %s");
add(Op.NE, "%s != %s",25);
add(Op.INARRAY, "%s in (%s)");
add(Op.NOTINARRAY, "%s not in (%s)");
add(Op.INELEMENTS, "%s in elements(%s)");
add(Op.IN, "%s in %s");
add(Op.NOTIN, "%s not in %s");
add(Op.ISNULL, "%s is null",26);
add(Op.ISNOTNULL, "%s is not null",26);
add(Op.SIZE, "size(%s)");
@ -71,10 +70,8 @@ public class HqlOps extends Ops {
add(OpString.SUBSTR2ARGS, "substring(%s,%s,%s)");
add(OpString.TRIM, "trim(%s)");
add(OpString.UPPER, "upper(%s)");
// HQL specific
add(OpHql.EXISTS, "exists elements(%s)");
add(OpHql.SUM, "sum(%s)");
add(OpHql.SYSDATE, "sysdate");
add(OpHql.CURRENT_DATE, "current_date()");
@ -88,6 +85,12 @@ public class HqlOps extends Ops {
add(OpHql.YEAR, "year(%s)");
add(OpHql.MAXINDEX, "maxindex(%s)");
add(OpHql.MININDEX, "minindex(%s)");
// quantified expressions
add(OpQuant.ANY, "any %s");
add(OpQuant.ALL, "all %s");
add(OpQuant.EXISTS, "exists %s");
add(OpQuant.NOTEXISTS, "not exists %s");
}
private static void add(Op<?> op, String pattern){
@ -116,7 +119,6 @@ public class HqlOps extends Ops {
Op<Date> CURRENT_TIME = new OpImpl<Date>();
Op<Date> CURRENT_TIMESTAMP = new OpImpl<Date>();
Op<Date> DAY = new OpImpl<Date>();
Op<Boolean> EXISTS = new OpImpl<Boolean>();
Op<Date> HOUR = new OpImpl<Date>();
Op<Boolean> ISEMPTY = new OpImpl<Boolean>();
Op<Boolean> ISNOTEMPTY = new OpImpl<Boolean>();
@ -130,4 +132,16 @@ public class HqlOps extends Ops {
Op<Date> YEAR = new OpImpl<Date>();
}
@SuppressWarnings("unchecked")
public interface OpQuant<RT>{
// some / any = true for any
// all = true for all
// exists = true is subselect matches
// not exists = true if subselect doesn't match
Op<?> ANY = new OpImpl();
Op<?> ALL = new OpImpl();
Op<?> EXISTS = new OpImpl();
Op<?> NOTEXISTS = new OpImpl();
}
}

122
querydsl-hibernate/src/main/java/com/mysema/query/grammar/HqlSerializer.java
View File

@ -5,14 +5,13 @@
*/
package com.mysema.query.grammar;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.*;
import com.mysema.query.JoinExpression;
import com.mysema.query.grammar.HqlGrammar.Constructor;
import com.mysema.query.grammar.HqlGrammar.CountExpr;
import com.mysema.query.grammar.HqlGrammar.DistinctPath;
import com.mysema.query.QueryBase;
import com.mysema.query.grammar.HqlGrammar.*;
import com.mysema.query.grammar.HqlOps.OpQuant;
import com.mysema.query.grammar.Ops.Op;
import com.mysema.query.grammar.Types.*;
/**
@ -22,16 +21,31 @@ import com.mysema.query.grammar.Types.*;
* @version $Id$
*/
public class HqlSerializer extends VisitorAdapter<HqlSerializer>{
private static final Set<Op<?>> wrapForOp;
static{
Set<Op<?>> ops = new HashSet<Op<?>>();
ops.add(Op.IN);
ops.add(Op.NOTIN);
ops.add(OpQuant.ALL);
ops.add(OpQuant.ANY);
ops.add(OpQuant.EXISTS);
ops.add(OpQuant.NOTEXISTS);
wrapForOp = Collections.unmodifiableSet(ops);
}
private StringBuilder builder = new StringBuilder();
private List<Object> constants = new ArrayList<Object>();
private boolean wrapElements = false;
private HqlSerializer _append(String str) {
builder.append(str);
return this;
}
private HqlSerializer _append(String sep, List<? extends Expr<?>> expressions) {
boolean first = true;
for (Expr<?> expr : expressions){
@ -40,7 +54,7 @@ public class HqlSerializer extends VisitorAdapter<HqlSerializer>{
}
return this;
}
private String _toString(Expr<?> expr, boolean wrap) {
StringBuilder old = builder;
builder = new StringBuilder();
@ -51,11 +65,11 @@ public class HqlSerializer extends VisitorAdapter<HqlSerializer>{
builder = old;
return ret;
}
public List<Object> getConstants(){
return constants;
}
public void serialize(List<Expr<?>> select, List<JoinExpression> joins,
List<ExprBoolean> where, List<Expr<?>> groupBy, List<ExprBoolean> having,
List<OrderSpecifier<?>> orderBy, boolean forCountRow){
@ -63,7 +77,7 @@ public class HqlSerializer extends VisitorAdapter<HqlSerializer>{
_append("select count(*)\n");
}else if (!select.isEmpty()){
_append("select ")._append(", ", select)._append("\n");
}
}
_append("from ");
for (int i=0; i < joins.size(); i++){
JoinExpression je = joins.get(i);
@ -76,7 +90,7 @@ public class HqlSerializer extends VisitorAdapter<HqlSerializer>{
case JOIN: sep = "\n join "; break;
case LEFTJOIN: sep = "\n left join "; break;
}
}
}
_append(sep);
}
// type specifier
@ -117,9 +131,9 @@ public class HqlSerializer extends VisitorAdapter<HqlSerializer>{
}
}
}
public String toString(){ return builder.toString(); }
public String toString(){ return builder.toString(); }
@Override
protected void visit(AliasSimple expr) {
handle(expr.getFrom())._append(" as ")._append(expr.getTo());
@ -127,11 +141,13 @@ public class HqlSerializer extends VisitorAdapter<HqlSerializer>{
@Override
protected void visit(AliasToPath expr) {
handle(expr.getFrom())._append(" as ").visit(expr.getTo());
handle(expr.getFrom())._append(" as ").visit(expr.getTo());
}
@Override
protected void visit(ConstantExpr<?> expr) {
boolean wrap = expr.getConstant().getClass().isArray();
if (wrap) _append("(");
_append(":a");
if (!constants.contains(expr.getConstant())){
constants.add(expr.getConstant());
@ -139,6 +155,7 @@ public class HqlSerializer extends VisitorAdapter<HqlSerializer>{
}else{
_append(Integer.toString(constants.indexOf(expr.getConstant())+1));
}
if (wrap) _append(")");
}
protected void visit(Constructor<?> expr){
@ -158,24 +175,27 @@ public class HqlSerializer extends VisitorAdapter<HqlSerializer>{
_append("distinct ").visit(expr.getPath());
}
@Override
protected void visit(Operation<?,?> expr) {
String pattern = HqlOps.getPattern(expr.getOperator());
if (pattern == null)
throw new IllegalArgumentException("Got no operation pattern for " + expr);
Object[] args = new Object[expr.getArgs().length];
int precedence = HqlOps.getPrecedence(expr.getOperator());
for (int i = 0; i < args.length; i++){
boolean wrap = false;
if (expr.getArgs()[i] instanceof Operation){
// wrap if outer operator precedes
wrap = precedence < HqlOps.getPrecedence(((Operation<?,?>)expr.getArgs()[i]).getOperator());
}
args[i] = _toString(expr.getArgs()[i],wrap);
}
_append(String.format(pattern, args));
protected void visit(ExprQuant q){
visitOperation(q.getOperator(), q.getTarget());
}
protected void visit(ExprQuantBoolean<?> q){
visit((ExprQuant)q);
}
protected void visit(ExprQuantComparable<?> q){
visit((ExprQuant)q);
}
protected void visit(ExprQuantSimple<?> q){
visit((ExprQuant)q);
}
@Override
protected void visit(Operation<?,?> expr) {
visitOperation(expr.getOperator(), expr.getArgs());
}
@Override
protected void visit(Path<?> path) {
if (path.getMetadata().getParent() != null){
@ -187,19 +207,47 @@ public class HqlSerializer extends VisitorAdapter<HqlSerializer>{
case MAPACCESS : _append("[").handle(expr)._append("]"); break;
case LISTACCESSC : _append("[")._append(expr.toString())._append("]"); break;
case MAPACCESSC : _append("[").handle(expr)._append("]"); break;
case MAXELEMENT : handle(expr)._append(".maxelement()"); break;
case MINELEMENT : handle(expr)._append(".minelement()"); break;
case PROPERTY : _append(".")._append(expr.toString()); break;
case VARIABLE : _append(expr.toString()); break;
}
}
@Override
protected void visit(SubQuery<?> subQuery) {
// TODO : replace this with a full sub query support
protected void visit(PathCollection<?> expr){
if (wrapElements) _append("elements(");
visit((Path<?>)expr);
if (wrapElements) _append(")");
}
protected void visit(SubQuery<?> query) {
QueryBase<?>.Metadata md = query.getQuery().getMetadata();
_append("(");
_append("\n select ").handle(subQuery._select());
_append("\n from ")._append(", ", subQuery._from());
_append("\n where ")._append(" and ", subQuery._where());
_append(")");
serialize(md.getSelect(), md.getJoins(),
md.getWhere(), md.getGroupBy(), md.getHaving(),
md.getOrderBy(), false);
_append(")");
}
private void visitOperation(Op<?> operator, Expr<?>... args) {
boolean old = wrapElements;
wrapElements = wrapForOp.contains(operator);
String pattern = HqlOps.getPattern(operator);
if (pattern == null)
throw new IllegalArgumentException("Got no operation pattern for " + operator);
Object[] strings = new Object[args.length];
int precedence = HqlOps.getPrecedence(operator);
for (int i = 0; i < strings.length; i++){
boolean wrap = false;
if (args[i] instanceof Operation){
// wrap if outer operator precedes
wrap = precedence < HqlOps.getPrecedence(((Operation<?,?>)args[i]).getOperator());
}
strings[i] = _toString(args[i],wrap);
}
_append(String.format(pattern, strings));
wrapElements = old;
}
}

9
querydsl-hibernate/src/test/java/com/mysema/query/grammar/hql/FeaturesTest.java
View File

@ -13,6 +13,7 @@ import static com.mysema.query.grammar.HqlGrammar.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import org.junit.Ignore;
import org.junit.Test;
import com.mysema.query.Domain1;
@ -266,12 +267,12 @@ public class FeaturesTest extends HqlQueryBase<FeaturesTest>{
}
@Test
@Ignore
public void testSubQuery(){
// TODO : make the comparison work again
StringBuilder b = new StringBuilder();
b.append("(");
b.append("\n select cust.name");
b.append("\n from cust");
b.append("\n where cust.name is not null)");
b.append("(select cust.name from cust");
b.append(" where cust.name is not null)");
toString(b.toString(), HqlGrammar.select(cust.name).from(cust).where(cust.name.isnotnull()));
}

23
querydsl-hibernate/src/test/java/com/mysema/query/grammar/hql/HqlDomain.java
View File

@ -89,6 +89,7 @@ public class HqlDomain {
public static class Customer {
@Id int id;
@ManyToOne Name name;
@ManyToOne Order currentOrder;
}
@Entity
@ -142,6 +143,7 @@ public class HqlDomain {
java.util.Date startDate;
public Foo(){}
public Foo(long l){}
public Foo(long l, long r){}
}
@Entity
@ -164,10 +166,16 @@ public class HqlDomain {
@Entity
public static class Name {
String firstName, lastName;
String firstName, lastName, nickName;
@Id long id;
}
@Entity
public static class NameList{
@Id long id;
@CollectionOfElements Collection<String> names;
}
@Entity
public static class Named {
@Id long id;
@ -205,6 +213,7 @@ public class HqlDomain {
@Id long i;
@ManyToOne PersonId id;
@ManyToOne Nationality nationality;
String name;
}
@Entity
@ -214,6 +223,12 @@ public class HqlDomain {
int medicareNumber;
}
@Entity
public static class Player{
@Id long id;
@CollectionOfElements List<Integer> scores;
}
@Entity
public static class Price {
long amount;
@ -234,6 +249,12 @@ public class HqlDomain {
@ManyToOne Location location;
}
@Entity
public static class doofus{
@Id long id;
String gob;
}
@Entity
public static class User {
@ManyToOne Company company;

45
querydsl-hibernate/src/test/java/com/mysema/query/grammar/hql/HqlParserTest.java
View File

@ -1,5 +1,6 @@
package com.mysema.query.grammar.hql;
import static com.mysema.query.grammar.Grammar.*;
import static com.mysema.query.grammar.HqlGrammar.*;
import static org.junit.Assert.assertEquals;
@ -15,7 +16,10 @@ import antlr.collections.AST;
import com.mysema.query.Domain1;
import com.mysema.query.Domain1Dtos;
import com.mysema.query.Domain1.Item;
import com.mysema.query.grammar.HqlGrammar;
import com.mysema.query.grammar.HqlQueryBase;
import com.mysema.query.grammar.Types.Expr;
import com.mysema.query.grammar.hql.HqlDomain.Color;
import com.mysema.query.grammar.hql.HqlDomain.DomesticCat;
import com.mysema.query.grammar.hql.HqlDomain.Payment;
@ -41,7 +45,7 @@ public class HqlParserTest extends HqlQueryBase<HqlParserTest>{
private Domain1.Calendar calendar = new Domain1.Calendar("calendar");
private Domain1.Cat cat = new Domain1.Cat("cat");
// private Domain1.Cat fatcat = new Domain1.Cat("fatcat");
private Domain1.Cat fatcat = new Domain1.Cat("fatcat");
private Domain1.Cat kittens = new Domain1.Cat("kittens");
private Domain1.Cat kitten = new Domain1.Cat("kitten");
private Domain1.Cat kit = new Domain1.Cat("kit");
@ -51,6 +55,8 @@ public class HqlParserTest extends HqlQueryBase<HqlParserTest>{
private Domain1.Cat qat = new Domain1.Cat("qat");
private Domain1.Cat rival = new Domain1.Cat("rival");
private Domain1.doofus d = new Domain1.doofus("d");
private Domain1.Customer cust = new Domain1.Customer("cust");
private Domain1.Foo foo = new Domain1.Foo("foo");
@ -59,16 +65,23 @@ public class HqlParserTest extends HqlQueryBase<HqlParserTest>{
private Domain1.Item item = new Domain1.Item("item");
private Domain1.Name name = new Domain1.Name("name");
private Domain1.Named m = new Domain1.Named("m");
private Domain1.Named n = new Domain1.Named("n");
private Domain1.NameList list = new Domain1.NameList("list");
private Domain1.Order ord = new Domain1.Order("ord");
private Domain1.Payment payment = new Domain1.Payment("payment");
private Domain1.Parameter param = new Domain1.Parameter("param");
private Domain1.Person person = new Domain1.Person("person");
private Domain1.Person person = new Domain1.Person("person");
private Domain1.Person p = new Domain1.Person("p");
private Domain1.Player player = new Domain1.Player("player");
private Domain1.Product prod = new Domain1.Product("prod");
@ -230,18 +243,18 @@ public class HqlParserTest extends HqlQueryBase<HqlParserTest>{
// parse( "from Order ord where maxindex(ord.items) > 100" );
from(ord).where(maxindex(ord.items).gt(100)).parse();
// parse( "from Order ord where minelement(ord.items) > 10000" );
// TODO
// from(ord).where(ord.items.minelement().gt(10000)).parse();
//
// parse( "select mother from eg.Cat as mother, eg.Cat as kit\n"
// + "where kit in elements(foo.kittens)" );
select(mother).from(mother, kit).where(kit.in(mother.kittens)).parse();
// parse( "select p from eg.NameList list, eg.Person p\n"
// + "where p.name = some elements(list.names)" );
// TODO
select(p).from(list,p).where(p.name.eq(some(list.names))).parse();
// parse( "from eg.Cat cat where exists elements(cat.kittens)" );
from(cat).where(exists(cat.kittens)).parse();
// parse( "from eg.Player p where 3 > all elements(p.scores)" );
// TODO
from(player).where(all(player.scores).lt(3)).parse();
// parse( "from eg.Show show where 'fizard' in indices(show.acts)" );
// TODO
// parse( "from Order ord where ord.items[0].id = 1234" );
@ -271,11 +284,11 @@ public class HqlParserTest extends HqlQueryBase<HqlParserTest>{
// + "where prod.name = 'widget'\n"
// + "and store.location.name in ( 'Melbourne', 'Sydney' )\n"
// + "and prod = all elements(cust.currentOrder.lineItems)" );
select(cust).from(prod, store).innerJoin(store.customers.as(cust))
.where(prod.name.eq("widget")
.and(store.location().name.in("Melbourne","Sydney"))
// .and()
).parse();
// select(cust).from(prod, store).innerJoin(store.customers.as(cust))
// .where(prod.name.eq("widget")
// .and(store.location().name.in("Melbourne","Sydney"))
// .and(prod.eq(all(cust.currentOrder().lineItems)))
// ).parse();
}
@Test
@ -310,16 +323,18 @@ public class HqlParserTest extends HqlQueryBase<HqlParserTest>{
public void testDocoExamples911() throws Exception {
// parse( "from eg.Cat as fatcat where fatcat.weight > (\n"
// + "select avg(cat.weight) from eg.DomesticCat cat)" );
// TODO
from(fatcat).where(fatcat.weight.gt(
HqlGrammar.select(avg(cat.weight)).from(cat))).parse();
// parse( "from eg.DomesticCat as cat where cat.name = some (\n"
// + "select name.nickName from eg.Name as name)\n" );
// TODO
from(cat).where(cat.name.eq(some(
HqlGrammar.select(name.nickName).from(name)))).parse();
// parse( "from eg.Cat as cat where not exists (\n"
// + "from eg.Cat as mate where mate.mate = cat)" );
// TODO
from(cat).where(notExists(HqlGrammar.from(mate).where(mate.mate.eq(cat)))).parse();
// parse( "from eg.DomesticCat as cat where cat.name not in (\n"
// + "select name.nickName from eg.Name as name)" );
// TODO
from(cat).where(cat.name.notIn(HqlGrammar.select(name.nickName).from(name))).parse();
}
@Test
@ -461,7 +476,7 @@ public class HqlParserTest extends HqlQueryBase<HqlParserTest>{
// parse( "select new Foo(count(bar)) from bar" );
select(new Domain1Dtos.Foo(count(bar))).from(bar).parse();
// parse( "select new Foo(count(bar),(select count(*) from doofus d where d.gob = 'fat' )) from bar" );
// TODO
select(new Domain1Dtos.Foo(count(bar), HqlGrammar.select(count()).from(d).where(d.gob.eq("fat")))).from(bar).parse();
}
@Test