mirror of
https://github.com/querydsl/querydsl.git
synced 2026-06-30 21:08:30 +08:00
507 lines
16 KiB
Java
507 lines
16 KiB
Java
/*
|
|
* Copyright (c) 2010 Mysema Ltd.
|
|
* All rights reserved.
|
|
*
|
|
*/
|
|
package com.mysema.query;
|
|
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.assertNotNull;
|
|
import static org.junit.Assert.assertNull;
|
|
import static org.junit.Assert.assertTrue;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Calendar;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
|
|
import org.junit.Before;
|
|
import org.junit.Test;
|
|
|
|
import com.mysema.commons.lang.Pair;
|
|
import com.mysema.query.jpa.JPQLQuery;
|
|
import com.mysema.query.jpa.JPQLSubQuery;
|
|
import com.mysema.query.jpa.domain.Cat;
|
|
import com.mysema.query.jpa.domain.DomesticCat;
|
|
import com.mysema.query.jpa.domain.Employee;
|
|
import com.mysema.query.jpa.domain.JobFunction;
|
|
import com.mysema.query.jpa.domain.QCat;
|
|
import com.mysema.query.jpa.domain.QEmployee;
|
|
import com.mysema.query.jpa.domain.QShow;
|
|
import com.mysema.query.jpa.domain.QUser;
|
|
import com.mysema.query.jpa.domain.Show;
|
|
import com.mysema.query.types.ArrayConstructorExpression;
|
|
import com.mysema.query.types.Concatenation;
|
|
import com.mysema.query.types.ConstructorExpression;
|
|
import com.mysema.query.types.Expression;
|
|
import com.mysema.query.types.ParamNotSetException;
|
|
import com.mysema.query.types.QTuple;
|
|
import com.mysema.query.types.expr.BooleanExpression;
|
|
import com.mysema.query.types.expr.ListExpression;
|
|
import com.mysema.query.types.expr.Param;
|
|
import com.mysema.query.types.expr.SimpleExpression;
|
|
import com.mysema.query.types.expr.StringExpression;
|
|
import com.mysema.query.types.path.ListPath;
|
|
|
|
/**
|
|
* @author tiwe
|
|
*
|
|
*/
|
|
public abstract class AbstractStandardTest {
|
|
|
|
public static class Projection {
|
|
|
|
public Projection(String str, Cat cat) {}
|
|
|
|
}
|
|
|
|
public static class QProjection extends ConstructorExpression<Projection>{
|
|
|
|
private static final long serialVersionUID = -5866362075090550839L;
|
|
|
|
public QProjection(StringExpression str, QCat cat){
|
|
super(Projection.class, new Class[]{String.class, Cat.class}, new Expression[]{str, cat});
|
|
}
|
|
|
|
}
|
|
|
|
private static final QCat cat = QCat.cat;
|
|
|
|
private static final QCat otherCat = new QCat("otherCat");
|
|
|
|
private static final BooleanExpression cond1 = cat.name.length().gt(0);
|
|
|
|
private static final BooleanExpression cond2 = otherCat.name.length().gt(0);
|
|
|
|
private final Date birthDate;
|
|
|
|
private final java.sql.Date date;
|
|
|
|
private final ProjectionsFactory projections = new ProjectionsFactory(Module.HQL, getTarget()){
|
|
@Override
|
|
public <A,Q extends SimpleExpression<A>> Collection<Expression<?>> list(ListPath<A,Q> expr, ListExpression<A,Q> other, A knownElement){
|
|
// NOTE : expr.get(0) is only supported in the where clause
|
|
return Collections.<Expression<?>>singleton(expr.size());
|
|
}
|
|
};
|
|
|
|
private final List<Cat> savedCats = new ArrayList<Cat>();
|
|
|
|
private final QueryExecution standardTest = new QueryExecution(
|
|
projections, new FilterFactory(projections, Module.HQL, getTarget()), new MatchingFiltersFactory(Module.HQL, getTarget())){
|
|
|
|
@Override
|
|
protected Pair<Projectable, List<Expression<?>>> createQuery() {
|
|
// NOTE : EclipseLink needs extra conditions cond1 and code2
|
|
return Pair.of(
|
|
(Projectable)query().from(cat, otherCat).where(cond1, cond2),
|
|
Arrays.<Expression<?>>asList());
|
|
}
|
|
@Override
|
|
protected Pair<Projectable, List<Expression<?>>> createQuery(BooleanExpression filter) {
|
|
// NOTE : EclipseLink needs extra conditions cond1 and code2
|
|
return Pair.of(
|
|
(Projectable)query().from(cat, otherCat).where(cond1, cond2, filter),
|
|
Arrays.<Expression<?>>asList(cat.name, otherCat.name));
|
|
}
|
|
};
|
|
|
|
private final java.sql.Time time;
|
|
|
|
{
|
|
Calendar cal = Calendar.getInstance();
|
|
cal.set(2000, 1, 2, 3, 4);
|
|
cal.set(Calendar.MILLISECOND, 0);
|
|
birthDate = cal.getTime();
|
|
date = new java.sql.Date(cal.getTimeInMillis());
|
|
time = new java.sql.Time(cal.getTimeInMillis());
|
|
}
|
|
|
|
protected JPQLQuery catQuery(){
|
|
return query().from(cat);
|
|
}
|
|
|
|
protected abstract Target getTarget();
|
|
|
|
protected abstract JPQLQuery query();
|
|
|
|
protected JPQLSubQuery subQuery(){
|
|
return new JPQLSubQuery();
|
|
}
|
|
|
|
protected abstract void save(Object entity);
|
|
|
|
@Before
|
|
public void setUp(){
|
|
Cat prev = null;
|
|
for (Cat cat : Arrays.asList(
|
|
new Cat("Bob123", 1, 1.0),
|
|
new Cat("Ruth123", 2, 2.0),
|
|
new Cat("Felix123", 3, 3.0),
|
|
new Cat("Allen123", 4, 4.0),
|
|
new Cat("Mary123", 5, 5.0))){
|
|
if (prev != null){
|
|
cat.addKitten(prev);
|
|
}
|
|
cat.setBirthdate(birthDate);
|
|
cat.setDateField(date);
|
|
cat.setTimeField(time);
|
|
save(cat);
|
|
savedCats.add(cat);
|
|
prev = cat;
|
|
}
|
|
|
|
Cat cat = new Cat("Some", 6, 6.0);
|
|
cat.setBirthdate(birthDate);
|
|
save(cat);
|
|
savedCats.add(cat);
|
|
|
|
Show show = new Show(1);
|
|
show.acts = new HashMap<String,String>();
|
|
show.acts.put("a","A");
|
|
show.acts.put("b","B");
|
|
save(show);
|
|
|
|
Employee employee = new Employee();
|
|
employee.jobFunctions.add(JobFunction.CODER);
|
|
save(employee);
|
|
}
|
|
|
|
@Test
|
|
public void test(){
|
|
Cat kitten = savedCats.get(0);
|
|
Cat noKitten = savedCats.get(savedCats.size()-1);
|
|
|
|
// standardTest.runArrayTests(cat.kittensArray, otherCat.kittensArray, kitten, noKitten);
|
|
standardTest.runBooleanTests(cat.name.isNull(), otherCat.kittens.isEmpty());
|
|
standardTest.runCollectionTests(cat.kittens, otherCat.kittens, kitten, noKitten);
|
|
standardTest.runDateTests(cat.dateField, otherCat.dateField, date);
|
|
standardTest.runDateTimeTests(cat.birthdate, otherCat.birthdate, birthDate);
|
|
standardTest.runListTests(cat.kittens, otherCat.kittens, kitten, noKitten);
|
|
// standardTest.mapTests(cat.kittensByName, otherCat.kittensByName, "Kitty", kitten);
|
|
|
|
// int
|
|
standardTest.runNumericCasts(cat.id, otherCat.id, 1);
|
|
standardTest.runNumericTests(cat.id, otherCat.id, 1);
|
|
|
|
// double
|
|
standardTest.runNumericCasts(cat.bodyWeight, otherCat.bodyWeight, 1.0);
|
|
standardTest.runNumericTests(cat.bodyWeight, otherCat.bodyWeight, 1.0);
|
|
|
|
standardTest.runStringTests(cat.name, otherCat.name, kitten.getName());
|
|
standardTest.runTimeTests(cat.timeField, otherCat.timeField, time);
|
|
|
|
standardTest.report();
|
|
}
|
|
|
|
@Test
|
|
public void Any_Simple(){
|
|
assertEquals(1, catQuery().where(cat.kittens.any().name.eq("Ruth123")).count());
|
|
}
|
|
|
|
@Test
|
|
public void Exists(){
|
|
assertTrue(catQuery().where(cat.kittens.any().name.eq("Ruth123")).exists());
|
|
}
|
|
|
|
@Test
|
|
public void NotExists(){
|
|
assertTrue(catQuery().where(cat.kittens.any().name.eq("XXX")).notExists());
|
|
}
|
|
|
|
@Test
|
|
public void Any_And_Lt(){
|
|
assertEquals(1, catQuery().where(cat.kittens.any().name.eq("Ruth123"), cat.kittens.any().bodyWeight.lt(10.0)).count());
|
|
}
|
|
|
|
@Test
|
|
public void Any_And_Gt(){
|
|
assertEquals(0, catQuery().where(cat.kittens.any().name.eq("Ruth123"), cat.kittens.any().bodyWeight.gt(10.0)).count());
|
|
}
|
|
|
|
@Test
|
|
public void Aggregates_UniqueResult_Min(){
|
|
assertEquals(Integer.valueOf(1), catQuery().uniqueResult(cat.id.min()));
|
|
}
|
|
|
|
@Test
|
|
public void Aggregates_UniqueResult_Max(){
|
|
assertEquals(Integer.valueOf(6), catQuery().uniqueResult(cat.id.max()));
|
|
}
|
|
|
|
@Test
|
|
public void Aggregates_List_Min(){
|
|
assertEquals(Integer.valueOf(1), catQuery().list(cat.id.min()).get(0));
|
|
}
|
|
|
|
@Test
|
|
public void Aggregates_List_Max(){
|
|
assertEquals(Integer.valueOf(6), catQuery().list(cat.id.max()).get(0));
|
|
}
|
|
|
|
@Test
|
|
public void DistinctResults(){
|
|
System.out.println("-- list results");
|
|
SearchResults<Date> res = catQuery().limit(2).listResults(cat.birthdate);
|
|
assertEquals(2, res.getResults().size());
|
|
assertEquals(6l, res.getTotal());
|
|
System.out.println();
|
|
|
|
System.out.println("-- list distinct results");
|
|
res = catQuery().limit(2).listDistinctResults(cat.birthdate);
|
|
assertEquals(1, res.getResults().size());
|
|
assertEquals(1l, res.getTotal());
|
|
System.out.println();
|
|
|
|
System.out.println("-- list distinct");
|
|
assertEquals(1, catQuery().listDistinct(cat.birthdate).size());
|
|
}
|
|
|
|
@Test
|
|
public void In(){
|
|
catQuery().where(cat.id.in(Arrays.asList(1,2,3))).count();
|
|
catQuery().where(cat.name.in(Arrays.asList("A","B","C"))).count();
|
|
}
|
|
|
|
@Test
|
|
public void StartsWith(){
|
|
assertEquals(1, catQuery().where(cat.name.startsWith("R")).count());
|
|
}
|
|
|
|
@Test
|
|
public void StartsWith2(){
|
|
assertEquals(0, catQuery().where(cat.name.startsWith("X")).count());
|
|
}
|
|
|
|
@Test
|
|
public void StartsWith_IgnoreCase(){
|
|
assertEquals(1, catQuery().where(cat.name.startsWithIgnoreCase("r")).count());
|
|
}
|
|
|
|
@Test
|
|
public void EndsWith(){
|
|
assertEquals(1, catQuery().where(cat.name.endsWith("h123")).count());
|
|
}
|
|
|
|
@Test
|
|
public void EndsWith2(){
|
|
assertEquals(0, catQuery().where(cat.name.endsWith("X")).count());
|
|
}
|
|
|
|
@Test
|
|
public void EndsWith_IgnoreCase(){
|
|
assertEquals(1, catQuery().where(cat.name.endsWithIgnoreCase("H123")).count());
|
|
}
|
|
|
|
@Test
|
|
public void Contains1(){
|
|
assertEquals(1, catQuery().where(cat.name.contains("eli")).count());
|
|
}
|
|
|
|
@Test
|
|
public void Contains2(){
|
|
assertEquals(1l, catQuery().where(cat.kittens.contains(savedCats.get(0))).count());
|
|
}
|
|
|
|
@Test
|
|
public void Length(){
|
|
assertEquals(6, catQuery().where(cat.name.length().gt(0)).count());
|
|
}
|
|
|
|
@Test
|
|
public void IndexOf(){
|
|
assertEquals(Integer.valueOf(0), catQuery().where(cat.name.eq("Bob123")).uniqueResult(cat.name.indexOf("B")));
|
|
}
|
|
|
|
@Test
|
|
public void IndexOf2(){
|
|
assertEquals(Integer.valueOf(1), catQuery().where(cat.name.eq("Bob123")).uniqueResult(cat.name.indexOf("o")));
|
|
}
|
|
|
|
@Test
|
|
public void StringOperations(){
|
|
if (!getTarget().equals(Target.MYSQL)){ // NOTE : locate in MYSQL is case-insensitive
|
|
assertEquals(0, catQuery().where(cat.name.startsWith("r")).count());
|
|
assertEquals(0, catQuery().where(cat.name.endsWith("H123")).count());
|
|
assertEquals(Integer.valueOf(2), catQuery().where(cat.name.eq("Bob123")).uniqueResult(cat.name.indexOf("b")));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void Limit(){
|
|
List<String> names1 = Arrays.asList("Allen123","Bob123");
|
|
assertEquals(names1, catQuery().orderBy(cat.name.asc()).limit(2).list(cat.name));
|
|
}
|
|
|
|
@Test
|
|
public void Limit2(){
|
|
assertEquals(Collections.singletonList("Allen123"), catQuery().orderBy(cat.name.asc()).limit(1).list(cat.name));
|
|
}
|
|
|
|
@Test
|
|
public void Offset(){
|
|
List<String> names2 = Arrays.asList("Felix123","Mary123","Ruth123","Some");
|
|
assertEquals(names2, catQuery().orderBy(cat.name.asc()).offset(2).list(cat.name));
|
|
}
|
|
|
|
@Test
|
|
public void Limit_and_offset(){
|
|
List<String> names3 = Arrays.asList("Felix123","Mary123");
|
|
assertEquals(names3, catQuery().orderBy(cat.name.asc()).limit(2).offset(2).list(cat.name));
|
|
}
|
|
|
|
@Test
|
|
public void InstanceOf_Cat(){
|
|
assertEquals(6l, query().from(cat).where(cat.instanceOf(Cat.class)).count());
|
|
}
|
|
|
|
@Test
|
|
public void InstanceOf_DomensticCat(){
|
|
assertEquals(0l, query().from(cat).where(cat.instanceOf(DomesticCat.class)).count());
|
|
}
|
|
|
|
@Test
|
|
public void NestedProjection(){
|
|
Concatenation concat = new Concatenation(cat.name, cat.name);
|
|
List<Tuple> tuples = query().from(cat).list(new QTuple(cat.name, concat));
|
|
assertFalse(tuples.isEmpty());
|
|
for (Tuple tuple : tuples){
|
|
assertEquals(
|
|
tuple.get(concat),
|
|
tuple.get(cat.name)+tuple.get(cat.name));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void TupleProjection(){
|
|
List<Tuple> tuples = query().from(cat).list(new QTuple(cat.name, cat));
|
|
assertFalse(tuples.isEmpty());
|
|
for (Tuple tuple : tuples){
|
|
assertNotNull(tuple.get(cat.name));
|
|
assertNotNull(tuple.get(cat));
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Test
|
|
public void ArrayProjection(){
|
|
List<String[]> results = query().from(cat).list(new ArrayConstructorExpression<String>(String[].class, cat.name));
|
|
assertFalse(results.isEmpty());
|
|
for (String[] result : results){
|
|
assertNotNull(result[0]);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void ConstructorProjection(){
|
|
List<Projection> projections = query().from(cat).list(ConstructorExpression.create(Projection.class, cat.name, cat));
|
|
assertFalse(projections.isEmpty());
|
|
for (Projection projection : projections){
|
|
assertNotNull(projection);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void ConstructorProjection2(){
|
|
List<Projection> projections = query().from(cat).list(new QProjection(cat.name, cat));
|
|
assertFalse(projections.isEmpty());
|
|
for (Projection projection : projections){
|
|
assertNotNull(projection);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void Params(){
|
|
Param<String> name = new Param<String>(String.class,"name");
|
|
assertEquals("Bob123",query().from(cat).where(cat.name.eq(name)).set(name, "Bob123").uniqueResult(cat.name));
|
|
}
|
|
|
|
@Test
|
|
public void Params_anon(){
|
|
Param<String> name = new Param<String>(String.class);
|
|
assertEquals("Bob123",query().from(cat).where(cat.name.eq(name)).set(name, "Bob123").uniqueResult(cat.name));
|
|
}
|
|
|
|
@Test(expected=ParamNotSetException.class)
|
|
public void Params_not_set(){
|
|
Param<String> name = new Param<String>(String.class,"name");
|
|
assertEquals("Bob123",query().from(cat).where(cat.name.eq(name)).uniqueResult(cat.name));
|
|
}
|
|
|
|
@Test
|
|
public void Null_as_uniqueResult(){
|
|
assertNull(query().from(cat).where(cat.name.eq(UUID.randomUUID().toString())).uniqueResult(cat));
|
|
}
|
|
|
|
@Test
|
|
public void Map_ContainsKey(){
|
|
QShow show = QShow.show;
|
|
assertEquals(1l, query().from(show).where(show.acts.containsKey("a")).count());
|
|
}
|
|
|
|
@Test
|
|
public void Map_ContainsKey2(){
|
|
QShow show = QShow.show;
|
|
assertEquals(1l, query().from(show).where(show.acts.containsKey("b")).count());
|
|
}
|
|
|
|
@Test
|
|
public void Map_ContainsKey3(){
|
|
QShow show = QShow.show;
|
|
assertEquals(0l, query().from(show).where(show.acts.containsKey("c")).count());
|
|
}
|
|
|
|
@Test
|
|
public void Map_ContainsValue(){
|
|
QShow show = QShow.show;
|
|
assertEquals(1l, query().from(show).where(show.acts.containsValue("A")).count());
|
|
}
|
|
|
|
@Test
|
|
public void Map_ContainsValue2(){
|
|
QShow show = QShow.show;
|
|
assertEquals(1l, query().from(show).where(show.acts.containsValue("B")).count());
|
|
}
|
|
|
|
@Test
|
|
public void Map_ContainsValue3(){
|
|
QShow show = QShow.show;
|
|
assertEquals(0l, query().from(show).where(show.acts.containsValue("C")).count());
|
|
}
|
|
|
|
@Test
|
|
public void SubQuery(){
|
|
QShow show = QShow.show;
|
|
QShow show2 = new QShow("show2");
|
|
query().from(show).where(subQuery().from(show2).where(show2.id.ne(show.id)).count().gt(0)).count();
|
|
}
|
|
|
|
@Test
|
|
public void Count(){
|
|
QShow show = QShow.show;
|
|
assertTrue(query().from(show).count() > 0);
|
|
}
|
|
|
|
@Test
|
|
public void One_To_One(){
|
|
JPQLQuery query = query();
|
|
query.from(QEmployee.employee);
|
|
query.innerJoin(QEmployee.employee.user, QUser.user);
|
|
query.list(QEmployee.employee);
|
|
}
|
|
|
|
@Test
|
|
public void Enum_In() {
|
|
JPQLQuery query = query();
|
|
query.from(QEmployee.employee).where(QEmployee.employee.jobFunctions.contains(JobFunction.CODER));
|
|
assertEquals(1l, query.count());
|
|
}
|
|
|
|
}
|