276 lines
13 KiB
Java
276 lines
13 KiB
Java
package com.ankurm.hibernatedemo.query;
|
|
|
|
import static org.assertj.core.api.Assertions.assertThat;
|
|
|
|
import jakarta.persistence.EntityManager;
|
|
import jakarta.persistence.EntityManagerFactory;
|
|
import jakarta.persistence.criteria.CriteriaBuilder;
|
|
import jakarta.persistence.criteria.CriteriaDelete;
|
|
import jakarta.persistence.criteria.CriteriaQuery;
|
|
import jakarta.persistence.criteria.CriteriaUpdate;
|
|
import jakarta.persistence.criteria.Join;
|
|
import jakarta.persistence.criteria.JoinType;
|
|
import jakarta.persistence.criteria.Predicate;
|
|
import jakarta.persistence.criteria.Root;
|
|
import jakarta.persistence.criteria.Subquery;
|
|
import java.time.LocalDate;
|
|
import java.util.List;
|
|
import org.hibernate.stat.Statistics;
|
|
import org.hibernate.SessionFactory;
|
|
import org.junit.jupiter.api.BeforeEach;
|
|
import org.junit.jupiter.api.Test;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.boot.test.context.SpringBootTest;
|
|
|
|
/**
|
|
* Backs ankurm.com post 4880 (Criteria API). Docs: docs/16-criteria-queries.md.
|
|
*
|
|
* <p>Shares {@link Employee}/{@link Department} with {@link HqlQueryTest}. The static metamodel
|
|
* classes ({@link Employee_}, {@link Department_}) are real, generated by {@code
|
|
* hibernate-jpamodelgen} at build time (see the {@code annotationProcessorPaths} entry in
|
|
* pom.xml) -- not hand-written stand-ins.
|
|
*
|
|
* <p>Run with {@code ./mvnw -Dtest=CriteriaQueryTest test}.
|
|
*/
|
|
@SpringBootTest
|
|
class CriteriaQueryTest {
|
|
|
|
private static final Logger DEMO = LoggerFactory.getLogger("DEMO");
|
|
|
|
@Autowired
|
|
private EntityManagerFactory emf;
|
|
|
|
private Long engineeringId;
|
|
|
|
@BeforeEach
|
|
void seed() {
|
|
EntityManager em = emf.createEntityManager();
|
|
em.getTransaction().begin();
|
|
em.createQuery("DELETE FROM Employee").executeUpdate();
|
|
em.createQuery("DELETE FROM QueryDept").executeUpdate();
|
|
Department engineering = new Department("Engineering");
|
|
Department marketing = new Department("Marketing");
|
|
em.persist(engineering);
|
|
em.persist(marketing);
|
|
em.persist(new Employee("Ada", "Byron", 95_000.0, "ACTIVE", LocalDate.of(2019, 3, 1), engineering));
|
|
em.persist(new Employee("Grace", "Hopper", 98_000.0, "ACTIVE", LocalDate.of(2018, 6, 15), engineering));
|
|
em.persist(new Employee("Linus", "Torvalds", 92_000.0, "INACTIVE", LocalDate.of(2015, 1, 10), engineering));
|
|
em.persist(new Employee("Margaret", "Hamilton", 72_000.0, "ACTIVE", LocalDate.of(2020, 9, 1), marketing));
|
|
em.persist(new Employee("Katherine", "Johnson", 71_000.0, "ACTIVE", LocalDate.of(2021, 2, 20), marketing));
|
|
em.getTransaction().commit();
|
|
engineeringId = engineering.getId();
|
|
em.close();
|
|
}
|
|
|
|
private Statistics stats() {
|
|
return emf.unwrap(SessionFactory.class).getStatistics();
|
|
}
|
|
|
|
@Test
|
|
void basicSelection_returnsEveryRow() {
|
|
EntityManager em = emf.createEntityManager();
|
|
CriteriaBuilder cb = em.getCriteriaBuilder();
|
|
CriteriaQuery<Employee> cr = cb.createQuery(Employee.class);
|
|
Root<Employee> root = cr.from(Employee.class);
|
|
cr.select(root);
|
|
|
|
List<Employee> results = em.createQuery(cr).getResultList();
|
|
assertThat(results).hasSize(5);
|
|
em.close();
|
|
}
|
|
|
|
@Test
|
|
void stringPathPredicates_andCombined_filterCorrectly() {
|
|
EntityManager em = emf.createEntityManager();
|
|
CriteriaBuilder cb = em.getCriteriaBuilder();
|
|
CriteriaQuery<Employee> cr = cb.createQuery(Employee.class);
|
|
Root<Employee> root = cr.from(Employee.class);
|
|
|
|
Predicate salaryGreater = cb.gt(root.get("salary"), 90_000.0);
|
|
Predicate nameLike = cb.like(root.get("lastName"), "%o%");
|
|
|
|
cr.select(root).where(cb.and(salaryGreater, nameLike)).orderBy(cb.asc(root.get("lastName")));
|
|
|
|
List<Employee> filtered = em.createQuery(cr).getResultList();
|
|
// salary > 90000 keeps Byron/Hopper/Torvalds; lastName LIKE '%o%' does NOT narrow that
|
|
// set further -- "Byron", "Hopper" and "Torvalds" all contain an 'o'.
|
|
assertThat(filtered).extracting(Employee::getLastName).containsExactly("Byron", "Hopper", "Torvalds");
|
|
DEMO.info("stringPathPredicates: {}", filtered.stream().map(Employee::getLastName).toList());
|
|
em.close();
|
|
}
|
|
|
|
@Test
|
|
void staticMetamodel_isTypeSafeAndProducesTheSameResultAsStringPath() {
|
|
// The same query as above, but built through the generated Employee_ metamodel
|
|
// instead of root.get("salary") string paths. Proves the metamodel classes are real
|
|
// and functional, not just present on the classpath.
|
|
EntityManager em = emf.createEntityManager();
|
|
CriteriaBuilder cb = em.getCriteriaBuilder();
|
|
CriteriaQuery<Employee> cr = cb.createQuery(Employee.class);
|
|
Root<Employee> root = cr.from(Employee.class);
|
|
|
|
cr.select(root)
|
|
.where(cb.gt(root.get(Employee_.salary), 90_000.0))
|
|
.orderBy(cb.asc(root.get(Employee_.lastName)));
|
|
|
|
List<Employee> results = em.createQuery(cr).getResultList();
|
|
assertThat(results).extracting(Employee::getLastName).containsExactly("Byron", "Hopper", "Torvalds");
|
|
DEMO.info("staticMetamodel: {}", results.stream().map(Employee::getLastName).toList());
|
|
em.close();
|
|
}
|
|
|
|
@Test
|
|
void joinViaMetamodel_filtersByRelatedEntity() {
|
|
EntityManager em = emf.createEntityManager();
|
|
CriteriaBuilder cb = em.getCriteriaBuilder();
|
|
CriteriaQuery<Employee> cr = cb.createQuery(Employee.class);
|
|
Root<Employee> root = cr.from(Employee.class);
|
|
|
|
Join<Employee, Department> department = root.join(Employee_.department, JoinType.INNER);
|
|
cr.select(root).where(cb.equal(department.get(Department_.name), "Engineering"));
|
|
|
|
List<Employee> engineeringStaff = em.createQuery(cr).getResultList();
|
|
assertThat(engineeringStaff).hasSize(3);
|
|
DEMO.info("joinViaMetamodel: {} engineering employees", engineeringStaff.size());
|
|
em.close();
|
|
}
|
|
|
|
@Test
|
|
void rootJoin_doesNotForceEagerLoad_rootFetchDoes() {
|
|
// root.join() builds a SQL join for filtering but does NOT initialize the association
|
|
// for the returned entities -- touching it afterward is a separate SELECT per entity,
|
|
// the same N+1 risk as HQL's plain JOIN. root.fetch() actually populates it.
|
|
EntityManager em1 = emf.createEntityManager();
|
|
CriteriaBuilder cb1 = em1.getCriteriaBuilder();
|
|
CriteriaQuery<Employee> cr1 = cb1.createQuery(Employee.class);
|
|
Root<Employee> root1 = cr1.from(Employee.class);
|
|
root1.join(Employee_.department, JoinType.INNER);
|
|
cr1.select(root1);
|
|
stats().clear();
|
|
List<Employee> viaJoin = em1.createQuery(cr1).getResultList();
|
|
long afterSelect = stats().getPrepareStatementCount();
|
|
viaJoin.forEach(e -> e.getDepartment().getName());
|
|
long afterTouch = stats().getPrepareStatementCount();
|
|
assertThat(afterTouch).as("root.join() alone still requires extra SELECTs to read the association")
|
|
.isGreaterThan(afterSelect);
|
|
em1.close();
|
|
|
|
EntityManager em2 = emf.createEntityManager();
|
|
CriteriaBuilder cb2 = em2.getCriteriaBuilder();
|
|
CriteriaQuery<Employee> cr2 = cb2.createQuery(Employee.class);
|
|
Root<Employee> root2 = cr2.from(Employee.class);
|
|
root2.fetch(Employee_.department, JoinType.INNER);
|
|
cr2.select(root2).distinct(true);
|
|
stats().clear();
|
|
List<Employee> viaFetch = em2.createQuery(cr2).getResultList();
|
|
viaFetch.forEach(e -> e.getDepartment().getName());
|
|
long totalWithFetch = stats().getPrepareStatementCount();
|
|
assertThat(totalWithFetch).as("root.fetch() loads the association in the same SELECT")
|
|
.isEqualTo(1L);
|
|
DEMO.info("rootJoinVsFetch: join+touch={} statements, fetch+touch={} statement", afterTouch, totalWithFetch);
|
|
em2.close();
|
|
}
|
|
|
|
@Test
|
|
void aggregation_avgSalary_matchesHandComputedValue() {
|
|
EntityManager em = emf.createEntityManager();
|
|
CriteriaBuilder cb = em.getCriteriaBuilder();
|
|
CriteriaQuery<Double> avgQuery = cb.createQuery(Double.class);
|
|
Root<Employee> avgRoot = avgQuery.from(Employee.class);
|
|
avgQuery.select(cb.avg(avgRoot.get(Employee_.salary)));
|
|
|
|
Double averageSalary = em.createQuery(avgQuery).getSingleResult();
|
|
double expected = (95_000.0 + 98_000.0 + 92_000.0 + 72_000.0 + 71_000.0) / 5;
|
|
assertThat(averageSalary).isCloseTo(expected, org.assertj.core.data.Offset.offset(0.01));
|
|
DEMO.info("aggregation: average salary = {}", averageSalary);
|
|
em.close();
|
|
}
|
|
|
|
@Test
|
|
void subquery_findsAboveAverageEarners() {
|
|
EntityManager em = emf.createEntityManager();
|
|
CriteriaBuilder cb = em.getCriteriaBuilder();
|
|
CriteriaQuery<Employee> mainQuery = cb.createQuery(Employee.class);
|
|
Root<Employee> empRoot = mainQuery.from(Employee.class);
|
|
|
|
Subquery<Double> sub = mainQuery.subquery(Double.class);
|
|
Root<Employee> subRoot = sub.from(Employee.class);
|
|
sub.select(cb.avg(subRoot.get(Employee_.salary)));
|
|
|
|
mainQuery.select(empRoot).where(cb.gt(empRoot.get(Employee_.salary), sub)).orderBy(cb.asc(empRoot.get(Employee_.lastName)));
|
|
|
|
List<Employee> highEarners = em.createQuery(mainQuery).getResultList();
|
|
// Company-wide average is 85600 (428000/5) -- the two Marketing salaries (72000,
|
|
// 71000) drag it well below every Engineering salary, so all three Engineering
|
|
// employees clear it, not just the single highest earner.
|
|
assertThat(highEarners).extracting(Employee::getLastName).containsExactly("Byron", "Hopper", "Torvalds");
|
|
DEMO.info("subquery: above-average earners (avg=85600) = {}", highEarners.stream().map(Employee::getLastName).toList());
|
|
em.close();
|
|
}
|
|
|
|
@Test
|
|
void criteriaUpdate_bulkRaisesSalaryForOneDepartment() {
|
|
EntityManager em = emf.createEntityManager();
|
|
em.getTransaction().begin();
|
|
CriteriaBuilder cb = em.getCriteriaBuilder();
|
|
|
|
CriteriaUpdate<Employee> update = cb.createCriteriaUpdate(Employee.class);
|
|
Root<Employee> updRoot = update.from(Employee.class);
|
|
update.set(Employee_.salary, cb.prod(updRoot.get(Employee_.salary), 1.1))
|
|
.where(cb.equal(updRoot.get(Employee_.department).get(Department_.id), engineeringId));
|
|
|
|
int updated = em.createQuery(update).executeUpdate();
|
|
assertThat(updated).isEqualTo(3);
|
|
|
|
em.clear();
|
|
Double newAdaSalary = em.createQuery("SELECT e.salary FROM Employee e WHERE e.lastName = 'Byron'", Double.class)
|
|
.getSingleResult();
|
|
assertThat(newAdaSalary).isCloseTo(95_000.0 * 1.1, org.assertj.core.data.Offset.offset(0.01));
|
|
em.getTransaction().commit();
|
|
DEMO.info("criteriaUpdate: {} rows updated, Ada's new salary = {}", updated, newAdaSalary);
|
|
em.close();
|
|
}
|
|
|
|
@Test
|
|
void criteriaDelete_removesEmployeesWithNoDepartment() {
|
|
EntityManager em = emf.createEntityManager();
|
|
em.getTransaction().begin();
|
|
// Insert one departmentless employee to have something real for CriteriaDelete to remove.
|
|
em.persist(new Employee("Orphan", "NoDept", 50_000.0, "ACTIVE", LocalDate.now(), null));
|
|
em.flush();
|
|
|
|
CriteriaBuilder cb = em.getCriteriaBuilder();
|
|
CriteriaDelete<Employee> delete = cb.createCriteriaDelete(Employee.class);
|
|
Root<Employee> delRoot = delete.from(Employee.class);
|
|
delete.where(cb.isNull(delRoot.get(Employee_.department)));
|
|
|
|
int deleted = em.createQuery(delete).executeUpdate();
|
|
assertThat(deleted).isEqualTo(1);
|
|
|
|
long remaining = em.createQuery("SELECT COUNT(e) FROM Employee e", Long.class).getSingleResult();
|
|
assertThat(remaining).isEqualTo(5L);
|
|
em.getTransaction().commit();
|
|
DEMO.info("criteriaDelete: deleted={}, remaining={}", deleted, remaining);
|
|
em.close();
|
|
}
|
|
|
|
@Test
|
|
void orPredicate_combinesConditionsWithVarargsOverload() {
|
|
EntityManager em = emf.createEntityManager();
|
|
CriteriaBuilder cb = em.getCriteriaBuilder();
|
|
CriteriaQuery<Employee> cr = cb.createQuery(Employee.class);
|
|
Root<Employee> root = cr.from(Employee.class);
|
|
|
|
cr.select(root).where(cb.or(
|
|
cb.equal(root.get(Employee_.status), "INACTIVE"),
|
|
cb.equal(root.get(Employee_.lastName), "Hamilton")));
|
|
|
|
List<Employee> results = em.createQuery(cr).getResultList();
|
|
assertThat(results).extracting(Employee::getLastName).containsExactlyInAnyOrder("Torvalds", "Hamilton");
|
|
DEMO.info("orPredicate: {}", results.stream().map(Employee::getLastName).toList());
|
|
em.close();
|
|
}
|
|
}
|