mirror of
https://github.com/querydsl/querydsl.git
synced 2026-06-13 21:01:01 +08:00
468 lines
17 KiB
Java
468 lines
17 KiB
Java
/*
|
|
* Copyright (c) 2008 Mysema Ltd.
|
|
* All rights reserved.
|
|
*
|
|
*/
|
|
package com.mysema.query.sql;
|
|
|
|
import static com.mysema.query.grammar.Grammar.avg;
|
|
import static com.mysema.query.grammar.Grammar.count;
|
|
import static com.mysema.query.grammar.Grammar.not;
|
|
import static com.mysema.query.grammar.QMath.add;
|
|
import static com.mysema.query.grammar.QMath.max;
|
|
import static com.mysema.query.grammar.QMath.min;
|
|
import static com.mysema.query.grammar.SqlGrammar.exists;
|
|
import static com.mysema.query.grammar.SqlGrammar.select;
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.fail;
|
|
|
|
import java.sql.Connection;
|
|
import java.sql.SQLException;
|
|
import java.sql.Statement;
|
|
import java.sql.Time;
|
|
import java.util.Arrays;
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
|
|
import org.junit.AfterClass;
|
|
import org.junit.Test;
|
|
|
|
import com.mysema.query.ExcludeIn;
|
|
import com.mysema.query.IncludeIn;
|
|
import com.mysema.query.grammar.QDateTime;
|
|
import com.mysema.query.grammar.QMath;
|
|
import com.mysema.query.grammar.QString;
|
|
import com.mysema.query.grammar.SqlJoinMeta;
|
|
import com.mysema.query.grammar.SqlOps;
|
|
import com.mysema.query.grammar.types.Expr;
|
|
import com.mysema.query.grammar.types.Projection;
|
|
import com.mysema.query.grammar.types.SubQuery;
|
|
import com.mysema.query.grammar.types.Expr.EBoolean;
|
|
import com.mysema.query.grammar.types.Expr.EComparable;
|
|
import com.mysema.query.grammar.types.Expr.ENumber;
|
|
import com.mysema.query.grammar.types.Expr.EString;
|
|
import com.mysema.query.sql.domain.QEMPLOYEE;
|
|
import com.mysema.query.sql.domain.QSURVEY;
|
|
import com.mysema.query.sql.domain.QTEST;
|
|
import com.mysema.query.sql.dto.IdName;
|
|
import com.mysema.query.sql.dto.QIdName;
|
|
|
|
|
|
/**
|
|
* SqlQueryTest provides SQL query tests for different DB types
|
|
*
|
|
* @author tiwe
|
|
* @version $Id$
|
|
*/
|
|
public abstract class SqlQueryTest {
|
|
|
|
protected static ThreadLocal<Connection> connHolder = new ThreadLocal<Connection>();
|
|
|
|
protected static ThreadLocal<Statement> stmtHolder = new ThreadLocal<Statement>();
|
|
|
|
protected SqlOps dialect;
|
|
|
|
protected final QEMPLOYEE employee = new QEMPLOYEE("employee");
|
|
protected final QEMPLOYEE employee2 = new QEMPLOYEE("employee2");
|
|
protected final QSURVEY survey = new QSURVEY("survey");
|
|
protected final QSURVEY survey2 = new QSURVEY("survey2");
|
|
protected final QTEST test = new QTEST("test");
|
|
|
|
protected String expectedQuery;
|
|
|
|
@AfterClass
|
|
public static void tearDown() throws Exception{
|
|
if (stmtHolder.get() != null) stmtHolder.get().close();
|
|
if (connHolder.get() != null) connHolder.get().close();
|
|
}
|
|
|
|
@Test
|
|
public void testQuery1() throws Exception{
|
|
for (String s : q().from(survey).list(survey.name)){
|
|
System.out.println(s);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testQuery2() throws Exception{
|
|
for (Object[] row : q().from(survey).list(survey.id, survey.name)){
|
|
System.out.println(row[0]+", " + row[1]);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testQueryWithConstant() throws Exception{
|
|
for (Object[] row : q().from(survey)
|
|
.where(survey.id.eq(1))
|
|
.list(survey.id, survey.name)){
|
|
System.out.println(row[0]+", " + row[1]);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testJoin() throws Exception{
|
|
for (String name : q().from(survey, survey2)
|
|
.where(survey.id.eq(survey2.id))
|
|
.list(survey.name)){
|
|
System.out.println(name);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testConstructor() throws Exception{
|
|
for (IdName idName : q().from(survey)
|
|
.list(new QIdName(survey.id, survey.name))){
|
|
System.out.println("id and name : " + idName.getId()+ ","+idName.getName());
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testVarious() throws SQLException{
|
|
System.out.println(q().from(survey).list(survey.name.lower()));
|
|
System.out.println(q().from(survey).list(survey.name.add("abc")));
|
|
System.out.println(q().from(survey).list(QMath.sqrt(survey.id)));
|
|
}
|
|
|
|
@Test
|
|
public void testColumnAlias() throws SQLException{
|
|
q().from(employee).list(
|
|
employee.firstname.as("fn"),
|
|
employee.firstname.lower().as("fnLc"));
|
|
}
|
|
|
|
@Test
|
|
public void testSelectConcat() throws SQLException{
|
|
System.out.println(q().from(survey).list(survey.name.add("Hello World")));
|
|
}
|
|
|
|
@Test
|
|
@ExcludeIn({"oracle","derby"})
|
|
public void testSelectBooleanExpr() throws SQLException{
|
|
// TODO : FIXME
|
|
System.out.println(q().from(survey).list(survey.id.eq(0)));
|
|
}
|
|
|
|
@Test
|
|
@ExcludeIn({"oracle","derby"})
|
|
public void testSelectBooleanExpr2() throws SQLException{
|
|
// TODO : FIXME
|
|
System.out.println(q().from(survey).list(survey.id.gt(0)));
|
|
}
|
|
|
|
@Test
|
|
public void testSyntaxForTest() throws SQLException{
|
|
// TEST
|
|
// select count(*) from test where name = null
|
|
expectedQuery = "select count(*) from test test where test.name is null";
|
|
q().from(test).where(test.name.isnull()).count();
|
|
// select count(*) from test where name like null
|
|
// q().from(test).where(test.name.like(null)).count();
|
|
// select count(*) from test where name = ''
|
|
q().from(test).where(test.name.like("")).count();
|
|
// select count(*) from test where name is not null
|
|
q().from(test).where(test.name.isnotnull()).count();
|
|
// select count(*) from test where name like '%'
|
|
q().from(test).where(test.name.like("%")).count();
|
|
// select count(*) from test where left(name, 6) = 'name44'
|
|
q().from(test).where(test.name.substring(0,6).like("name44%")).count();
|
|
// select count(*) from test where name like 'name44%'
|
|
q().from(test).where(test.name.like("name44%")).count();
|
|
// select count(*) from test where left(name,5) = 'name4' and right(name,1) = 5
|
|
// TODO
|
|
// select count(*) from test where name like 'name4%5'
|
|
q().from(test).where(test.name.like("name4%5")).count();
|
|
// select count(*) from test where left(name,5) = 'name4' and right(name,1) = 5
|
|
// TODO
|
|
// select count(*) from test where name like 'name4%5'
|
|
q().from(test).where(test.name.like("name4%5")).count();
|
|
}
|
|
|
|
@Test
|
|
public void testSyntaxForEmployee() throws SQLException{
|
|
// EMPLOYEE
|
|
// "select avg(salary), max(id) from employee "
|
|
// + "group by superior_id " + "order by superior_id " + "";
|
|
q().from(employee)
|
|
.groupBy(employee.superiorId)
|
|
.orderBy(employee.superiorId.asc())
|
|
.list(avg(employee.salary), max(employee.id));
|
|
|
|
// "select avg(salary), max(id) from employee "
|
|
// + "group by superior_id " + "having max(id) > 5 "
|
|
// + "order by superior_id " + "";
|
|
q().from(employee)
|
|
.groupBy(employee.superiorId).having(max(employee.id).gt(5))
|
|
.orderBy(employee.superiorId.asc())
|
|
.list(avg(employee.salary), max(employee.id));
|
|
|
|
// "select avg(salary), max(id) from employee "
|
|
// + "group by superior_id "
|
|
// + "having superior_id is not null "
|
|
// + "order by superior_id " + "";
|
|
q().from(employee)
|
|
.groupBy(employee.superiorId).having(employee.superiorId.isnotnull())
|
|
.orderBy(employee.superiorId.asc())
|
|
.list(avg(employee.salary),max(employee.id));
|
|
}
|
|
|
|
@Test
|
|
public void testJoins() throws SQLException{
|
|
for (Object[] row : q().from(employee).innerJoin(employee2)
|
|
.on(employee.superiorId.eq(employee2.superiorId))
|
|
.where(employee2.id.eq(10))
|
|
.list(employee.id, employee2.id)){
|
|
System.out.println(row[0] + ", " + row[1]);
|
|
}
|
|
}
|
|
|
|
class EmployeeProjection extends Projection{
|
|
public EmployeeProjection(String entityName) {
|
|
super(entityName);
|
|
}
|
|
Expr<Integer> id;
|
|
Expr<String> firstname;
|
|
Expr<Integer> superiorId;
|
|
}
|
|
|
|
@Test
|
|
public void testProjectionFromEntity() throws SQLException{
|
|
EmployeeProjection proj = new EmployeeProjection("proj");
|
|
for (Object[] row : q().from(employee).leftJoin(proj.from(employee2))
|
|
.on(proj.id.eq(employee.superiorId))
|
|
.list(employee.id, proj.id, proj.superiorId)){
|
|
System.out.println(row[0] + ", " + row[1]);
|
|
}
|
|
}
|
|
|
|
|
|
@Test
|
|
public void testProjectionFromSubQuery() throws SQLException{
|
|
EmployeeProjection proj = new EmployeeProjection("proj");
|
|
for (Object[] row : q().from(employee).leftJoin(
|
|
proj.from(select(employee2.id,employee2.firstname).from(employee2)))
|
|
.on(proj.id.eq(employee.superiorId))
|
|
.list(employee.id, proj.id)){
|
|
System.out.println(row[0] + ", " + row[1]);
|
|
}
|
|
}
|
|
|
|
|
|
@Test
|
|
public void testIllegal() throws SQLException{
|
|
// q().from(employee).list(employee);
|
|
}
|
|
|
|
@Test
|
|
@ExcludeIn({"oracle","derby"})
|
|
public void testLimitAndOffset() throws SQLException{
|
|
// limit offset
|
|
expectedQuery = "select employee.id from employee employee limit 4 offset 3";
|
|
q().from(employee).limit(4).offset(3).list(employee.id);
|
|
}
|
|
|
|
@Test
|
|
@IncludeIn("oracle")
|
|
public void testLimitAndOffsetInOracle() throws SQLException{
|
|
String prefix = "select employee.id from employee employee ";
|
|
|
|
// limit
|
|
expectedQuery = prefix + "where rownum < 4";
|
|
q().from(employee).limit(4).list(employee.id);
|
|
|
|
// offset
|
|
expectedQuery = prefix + "where rownum > 3";
|
|
q().from(employee).offset(3).list(employee.id);
|
|
|
|
// limit offset
|
|
expectedQuery = prefix + "where rownum between 4 and 7";
|
|
q().from(employee).limit(4).offset(3).list(employee.id);
|
|
}
|
|
|
|
@Test
|
|
public void testSubQueries() throws SQLException{
|
|
// subquery in where block
|
|
expectedQuery = "select employee.id from employee employee " +
|
|
"where employee.id = (select max(employee.id) " +
|
|
"from employee employee)";
|
|
List<Integer> list = q().from(employee).where(employee.id.eq(
|
|
select(max(employee.id)).from(employee)))
|
|
.list(employee.id);
|
|
assertFalse(list.isEmpty());
|
|
}
|
|
|
|
@Test
|
|
public void testIllegalUnion() throws SQLException{
|
|
SubQuery<SqlJoinMeta,Integer> sq1 = select(max(employee.id)).from(employee);
|
|
SubQuery<SqlJoinMeta,Integer> sq2 = select(min(employee.id)).from(employee);
|
|
try{
|
|
q().from(employee).union(sq1, sq2).list();
|
|
fail();
|
|
}catch(IllegalArgumentException e){
|
|
// expected
|
|
}
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testUnion() throws SQLException{
|
|
// union
|
|
SubQuery<SqlJoinMeta,Integer> sq1 = select(max(employee.id)).from(employee);
|
|
SubQuery<SqlJoinMeta,Integer> sq2 = select(min(employee.id)).from(employee);
|
|
List<Integer> list = q().union(sq1, sq2).list();
|
|
assertFalse(list.isEmpty());
|
|
|
|
// variation 1
|
|
list = q().union(
|
|
select(max(employee.id)).from(employee),
|
|
select(min(employee.id)).from(employee)).list();
|
|
assertFalse(list.isEmpty());
|
|
|
|
// union #2
|
|
SubQuery<SqlJoinMeta,Object[]> sq3 = select(count(), max(employee.id)).from(employee);
|
|
SubQuery<SqlJoinMeta,Object[]> sq4 = select(count(), min(employee.id)).from(employee);
|
|
List<Object[]> list2 = q().union(sq3, sq4).list();
|
|
assertFalse(list2.isEmpty());
|
|
}
|
|
|
|
@Test
|
|
@ExcludeIn({"hsqldb","derby"})
|
|
public void testQueryWithoutFrom() throws SQLException{
|
|
q().list(add(new Expr.EConstant<Integer>(1),1));
|
|
}
|
|
|
|
@Test
|
|
public void testWhereExists() throws SQLException{
|
|
SubQuery<SqlJoinMeta,Integer> sq1 = select(max(employee.id)).from(employee);
|
|
q().from(employee).where(exists(sq1)).count();
|
|
q().from(employee).where(not(exists(sq1))).count();
|
|
}
|
|
|
|
@Test
|
|
@ExcludeIn({"derby"})
|
|
public void testMathFunctions() throws SQLException{
|
|
Expr<Integer> i = new Expr.EConstant<Integer>(1);
|
|
Expr<Double> d = new Expr.EConstant<Double>(1.0);
|
|
for (Expr<?> e : Arrays.<Expr<?>>asList(
|
|
QMath.abs(i),
|
|
QMath.acos(d),
|
|
QMath.asin(d),
|
|
QMath.atan(d),
|
|
QMath.ceil(d),
|
|
QMath.cos(d),
|
|
QMath.tan(d),
|
|
QMath.sqrt(i),
|
|
QMath.sin(d),
|
|
QMath.round(d),
|
|
QMath.random(),
|
|
QMath.pow(d,d),
|
|
// QMath.min(i,i),
|
|
// QMath.max(i,i),
|
|
// QMath.mod(i,i),
|
|
QMath.log10(d),
|
|
QMath.log(d),
|
|
QMath.floor(d),
|
|
QMath.exp(d))){
|
|
q().from(employee).list((Expr<? extends Comparable>)e);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@ExcludeIn({"derby"})
|
|
public void testStringFunctions() throws SQLException{
|
|
EString s = employee.firstname;
|
|
for (EString e : Arrays.<EString>asList(
|
|
s.lower(),
|
|
s.upper(),
|
|
s.substring(1),
|
|
s.trim(),
|
|
s.concat("abc"),
|
|
QString.ltrim(s),
|
|
QString.rtrim(s),
|
|
// QString.length(s),
|
|
QString.space(4))){
|
|
q().from(employee).list(e);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testStringFunctions2() throws SQLException{
|
|
for (EBoolean where : Arrays.<EBoolean>asList(
|
|
employee.firstname.startsWith("a"),
|
|
employee.firstname.startsWith("a",false),
|
|
employee.firstname.endsWith("a"),
|
|
employee.firstname.endsWith("a",false))){
|
|
q().from(employee).where(where).list(employee.firstname);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@ExcludeIn({"derby"})
|
|
public void testDateTimeFunctions() throws SQLException{
|
|
Expr<Date> d = new Expr.EConstant<Date>(new Date());
|
|
Expr<Time> t = new Expr.EConstant<Time>(new Time(0));
|
|
for (EComparable<?> e : Arrays.<EComparable<?>>asList(
|
|
QDateTime.currentDate(),
|
|
QDateTime.currentTime(),
|
|
QDateTime.now(),
|
|
|
|
QDateTime.year(d),
|
|
QDateTime.month(d),
|
|
QDateTime.week(d),
|
|
|
|
QDateTime.hour(t),
|
|
QDateTime.minute(t),
|
|
QDateTime.second(t),
|
|
|
|
QDateTime.dayOfMonth(d),
|
|
QDateTime.dayOfWeek(d),
|
|
QDateTime.dayOfYear(d)
|
|
)){
|
|
q().from(employee).list(e);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@ExcludeIn({"derby"})
|
|
public void testCasts() throws SQLException{
|
|
ENumber<?> num = employee.id;
|
|
Expr<?>[] expr = new Expr[]{
|
|
num.byteValue(),
|
|
num.doubleValue(),
|
|
num.floatValue(),
|
|
num.intValue(),
|
|
num.longValue(),
|
|
num.shortValue(),
|
|
num.stringValue()};
|
|
|
|
for (Expr<?> e : expr){
|
|
q().from(employee).list(e);
|
|
}
|
|
|
|
}
|
|
|
|
protected static void executeSafe(String sql){
|
|
try {
|
|
stmtHolder.get().execute(sql);
|
|
} catch (SQLException e) {
|
|
// do nothing
|
|
}
|
|
}
|
|
|
|
protected final SqlQuery q(){
|
|
return new SqlQuery(connHolder.get(), dialect){
|
|
@Override
|
|
protected String buildQueryString() {
|
|
String rv = super.buildQueryString();
|
|
if (expectedQuery != null){
|
|
assertEquals(expectedQuery, rv);
|
|
expectedQuery = null;
|
|
}
|
|
System.out.println(rv);
|
|
return rv;
|
|
}
|
|
};
|
|
}
|
|
|
|
}
|