QueryDSL 简单的查询语句应用

1.//queryDSL查询返回一个对象
QCustomer customer = QCustomer.customer;
JPAQuery query = newJPAQuery(entityManager);
Customer bob = query.from(customer).where(customer.firstName.eq("Bob")).uniqueResult(customer);
2.//
QCustomer customer = QCustomer.customer;
QCompany company = QCompany.company;
query.from(customer, company);

query.from(customer).where(customer.firstName.eq("Bob"), customer.lastName.eq("Wilson"));

query.from(customer).where(customer.firstName.eq("Bob").and(customer.lastName.eq("Wilson")));
//The native JPQL version of the query would be
from Customer as customer where customer.firstName = "Bob" and customer.lastName = "Wilson";

query.from(customer).where(customer.firstName.eq("Bob").or(customer.lastName.eq("Wilson")));

3.//Using joins
QCat cat = QCat.cat;
QCat mate = newQCat("mate");
QCate kitten = newQCat("kitten");
query.from(cat).innerJoin(cat.mate, mate).leftJoin(cat.kittens, kitten).list(cat);

from Cat as cat inner join cat.mate as mate left outer join cat.kittens as kitten;

query.from(cat).leftJoin(cat.kittens, kitten).on(kitten.bodyWeight.gt(10.0)).list(cat);

from Cat as cat left join cat.kittens as kitten on kitten.bodyWeight > 10.0

4.//Ordering
QCustomer customer = QCustomer.customer;
query.from(customer).orderBy(customer.lastName.asc(), customer.firstName.desc()).list(customer);

from Customer as customer order by customer.lastName asc, customer.firstName desc

5.//Grouping
query.from(customer).groupBy(customer.lastName).list(customer.lastName);

select customer.lastName from Customer as customer group by customer.lastName

6.//Delete clauses
QCustomer customer = QCustomer.customer;
// delete all customers
new JPADeleteClause(entityManager, customer).execute();
// delete all customers with a level less than 3
new JPAeDeleteClause(entityManager, customer).where(customer.level.lt(3)).execute();

7.//Update clauses
QCustomer customer = QCustomer.customer;
// rename customers named Bob to Bobby
new JPAUpdateClause(session, customer).where(customer.name.eq("Bob")).set(customer.name, "Bobby").execute();

8.//Subqueries
QDepartment department = QDepartment.department;
QDepartment d = new QDepartment("d");
query.from(department).where(department.employees.size().eq(new JPASubQuery().from(d).unique(d.employees.size().max())
)).list(department);

QEmployee employee = QEmployee.employee;
QEmployee e = newQEmployee("e");
query.from(employee).where(employee.weeklyhours.gt(
new JPASubQuery().from(employee.department.employees, e).where(e.manager.eq(employee.manager)).unique(e.weeklyhours.avg())
)).list(employee);

9.//Using Native SQL in JPA queries
/*Maven配置

com.mysema.querydsl
querydsl-maven-plugin
${project.version}



export




org.apache.derby.jdbc.EmbeddedDriver
jdbc:derby:target/demoDB;create=true
com.mycompany.mydomain
${project.basedir}/target/generated-sources/java



org.apache.derby
derby
${derby.version}



*/
//Single column query
// serialization templates
SQLTemplates templates = newDerbyTemplates();
// query types (S* for SQL, Q* for domain types)
SAnimal cat = newSAnimal("cat");
SAnimal mate = newSAnimal("mate");
QCat catEntity = QCat.cat;
JPASQLQuery query = newJPASQLQuery(entityManager, templates);
List names = query.from(cat).list(cat.name);

//Query multiple columns
query = newJPASQLQuery(entityManager, templates);
List rows = query.from(cat).list(cat.id, cat.name);

//Query all columns
List rows = query.from(cat).list(cat.all());

//Query in SQL, but project as entity
query = newJPASQLQuery(entityManager, templates);
List cats = query.from(cat).orderBy(cat.name.asc()).list(catEntity);

//Query with joins
query = newJPASQLQuery(entityManager, templates);
cats = query.from(cat).innerJoin(mate).on(cat.mateId.eq(mate.id)).where(cat.dtype.eq("Cat"), mate.dtype.eq("Cat")).list(catEntity);

//Query and project into DTO
query = newJPASQLQuery(entityManager, templates);
List catDTOs = query.from(cat).orderBy(cat.name.asc()).list(ConstructorExpression.create(CatDTO.class, cat.id, cat.name));

10.//Ordering
QCustomer customer = QCustomer.customer;
query.from(customer).orderBy(customer.lastName.asc(), customer.firstName.desc()).list(customer);

11.//Grouping
query.from(customer).groupBy(customer.lastName).list(customer.lastName);

12.//Delete clauses
QCustomer customer = QCustomer.customer;
// delete all customers
newJDODeleteClause(pm, customer).execute();
// delete all customers with a level less than 3
newJDODeleteClause(pm, customer).where(customer.level.lt(3)).execute();

13.//Subqueries
//JDOSubQueryinstance
QDepartment department = QDepartment.department;
QDepartment d = newQDepartment("d");
query.from(department)
.where(department.employees.size().eq(newJDOSubQuery().from(d).unique(AggregationFunctions.max(d.employees.size()))
)).list(department);

//native JDO query
SELECT this FROM com.mysema.query.jdoql.models.company.Department
WHERE this.employees.size() == SELECT max(d.employees.size()) FROM com.mysema.query.jdoql.models.company.Department d)

QEmployee employee = QEmployee.employee;
QEmployee e = newQEmployee("e");
query.from(employee).where(employee.weeklyhours.gt(newJDOSubQuery().from(employee.department.employees, e)
.where(e.manager.eq(employee.manager)).unique(AggregationFunctions.avg(e.weeklyhours)))).list(employee);

//native JDO query
SELECT this FROM com.mysema.query.jdoql.models.company.Employee
WHERE this.weeklyhours > (SELECT avg(e.weeklyhours) FROM this.department.employees e WHERE e.manager == this.manager)

14.//Window functions
query.from(employee).list(SQLExpressions.rowNumber().over().partitionBy(employee.name).orderBy(employee.id));

15.//Insert
QSurvey survey = QSurvey.survey;
newSQLInsertClause(conn, dialect, survey).columns(survey.id, survey.name).values(3, "Hello").execute()

newSQLInsertClause(conn, dialect, survey).values(4, "Hello").execute();
//subquery
new SQLInsertClause(conn, dialect, survey).columns(survey.id, survey.name).select(newSQLSubQuery().from(survey2).list(survey2.id.add(1), survey2.name))
.execute();

new SQLInsertClause(conn, dialect, survey).select(newSQLSubQuery().from(survey2).list(survey2.id.add(10), survey2.name))
.execute();
16.//Update
QSurvey survey = QSurvey.survey;
new SQLUpdateClause(conn, dialect, survey).where(survey.name.eq("XXX")).set(survey.name, "S").execute();

new SQLUpdateClause(conn, dialect, survey).set(survey.name, "S").execute()

17.//Delete
QSurvey survey = QSurvey.survey;
new SQLDelecteClause(conn, dialect, survey).where(survey.name.eq("XXX")).execute();

new SQLDelecteClause(conn, dialect, survey).execute()

18.//Batch support in DML clauses
//Update:
QSurvey survey = QSurvey.survey;
insert(survey).values(2, "A").execute();
insert(survey).values(3, "B").execute();
SQLUpdateClause update = update(survey);
update.set(survey.name, "AA").where(survey.name.eq("A")).addBatch();
update.set(survey.name, "BB").where(survey.name.eq("B")).addBatch();
//Delete:
insert(survey).values(2, "A").execute();
insert(survey).values(3, "B").execute();
SQLDeleteClause delete = delete(survey);
delete.where(survey.name.eq("A")).addBatch();
delete.where(survey.name.eq("B")).addBatch();
assertEquals(2, delete.execute());
//Insert
SQLInsertClause insert = insert(survey);
insert.set(survey.id, 5).set(survey.name, "5").addBatch();
insert.set(survey.id, 6).set(survey.name, "6").addBatch();
assertEquals(2, insert.execute());

19.
//limit
query.where(doc.title.like("*")).limit(10).list();
//offset
query.where(doc.title.like("*")).offset(3).list();

20.//Fuzzy searches
query.where(LuceneExpressions.fuzzyLike(doc.title, "Hello")).list();
21.//Applying Lucene filters to queries
query.where(doc.title.like("*")).filter(filter).list();

query.where(doc.title.like("*")).distinct(doc.title).list()
22.//Querying Hibernate Search
QUser user = QUser.user;
SearchQuery query = newSearchQuery(session, user);
List list = query.where(user.firstName.eq("Bob")).list();

23.// Querying Mongodb
/*

com.mysema.querydsl
querydsl-apt
${querydsl.version}
provided


com.mysema.querydsl
querydsl-mongodb
${querydsl.version}


org.slf4j
slf4j-log4j12
1.6.1

*/
/*



...

com.mysema.maven
apt-maven-plugin
1.0.9



process


target/generated-sources/java
com.mysema.query.apt.morphia.MorphiaAnnotationProcessor




...



*/

24.//Result handling

List result = query.from(employee).list(employee.firstName, employee.lastName);
for(Tuple row : result) {
System.out.println("firstName "+ row.get(employee.firstName));
System.out.println("lastName "+ row.get(employee.lastName));
}}

List dtos = query.list(Projections.bean(UserDTO.class, user.firstName, user.lastName));

class CustomerDTO {
@QueryProjection
public  CustomerDTO(longid, String name){
...
}
}
QCustomer customer = QCustomer.customer;
JPQLQuery query = newHibernateQuery(session);
List dtos = query.from(customer).list(new QCustomerDTO(customer.id, customer.name));

QCustomer customer = QCustomer.customer;
JPQLQuery query = new HibernateQuery(session);
List dtos = query.from(customer).list(QCustomer.create(customer.id, customer.name));

List dtos = query.from(customer).list(ConstructorExpression.create(Customer.class, customer.id, customer.name));

25.//Result aggregation

import staticcom.mysema.query.group.GroupBy.*;
Map> results = query.from(post, comment).where(comment.post.id.eq(post.id)).transform(groupBy(post.id).as(list(comment)))

Map results = query.from(post, comment).where(comment.post.id.eq(post.id)).transform(groupBy(post.id).as(post.name, set(comment.id)));