From a824cdcc002263f12167c684c8a290376ef23a94 Mon Sep 17 00:00:00 2001 From: stvort Date: Fri, 6 Dec 2019 23:05:38 +0400 Subject: [PATCH] jpql-demo example has ben added --- examples/README.md | 3 +- examples/jpql-demo/.gitignore | 29 ++ examples/jpql-demo/README.md | 6 + examples/jpql-demo/pom.xml | 71 +++++ .../jpql_demo/JpqlDemoApplication.java | 13 + .../example/jpql_demo/dto/CitySalary.java | 15 + .../jpql_demo/dto/EmployeeProjects.java | 16 + .../example/jpql_demo/models/Address.java | 24 ++ .../example/jpql_demo/models/Department.java | 21 ++ .../example/jpql_demo/models/Employee.java | 53 ++++ .../example/jpql_demo/models/Project.java | 21 ++ .../repositories/EmployeeRepository.java | 49 +++ .../repositories/EmployeeRepositoryImpl.java | 237 +++++++++++++++ .../src/main/resources/application.yml | 15 + .../jpql-demo/src/main/resources/jpql.sql | 74 +++++ .../jpql-demo/src/main/resources/schema.sql | 39 +++ .../EmployeeRepositoryImplTest.java | 282 ++++++++++++++++++ .../src/test/resources/application.yml | 16 + .../src/test/resources/test-data.sql | 21 ++ 19 files changed, 1004 insertions(+), 1 deletion(-) create mode 100644 examples/jpql-demo/.gitignore create mode 100644 examples/jpql-demo/README.md create mode 100644 examples/jpql-demo/pom.xml create mode 100644 examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/JpqlDemoApplication.java create mode 100644 examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/dto/CitySalary.java create mode 100644 examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/dto/EmployeeProjects.java create mode 100644 examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Address.java create mode 100644 examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Department.java create mode 100644 examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Employee.java create mode 100644 examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Project.java create mode 100644 examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/repositories/EmployeeRepository.java create mode 100644 examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/repositories/EmployeeRepositoryImpl.java create mode 100644 examples/jpql-demo/src/main/resources/application.yml create mode 100644 examples/jpql-demo/src/main/resources/jpql.sql create mode 100644 examples/jpql-demo/src/main/resources/schema.sql create mode 100644 examples/jpql-demo/src/test/java/ru/otus/example/jpql_demo/repositories/EmployeeRepositoryImplTest.java create mode 100644 examples/jpql-demo/src/test/resources/application.yml create mode 100644 examples/jpql-demo/src/test/resources/test-data.sql diff --git a/examples/README.md b/examples/README.md index 77699970..9a45c9b6 100644 --- a/examples/README.md +++ b/examples/README.md @@ -9,4 +9,5 @@ * *docker-test-containers* - TestContainers * *spring-cloud-demo-stvort* - Config server, Eureka, Zuul, Feign client * *spring-mail-integration-demo* - SpringMail SpringIntegration -* *liquibase-demo* - liquibase \ No newline at end of file +* *liquibase-demo* - liquibase +* *jpql-demo* - JPQL \ No newline at end of file diff --git a/examples/jpql-demo/.gitignore b/examples/jpql-demo/.gitignore new file mode 100644 index 00000000..153c9335 --- /dev/null +++ b/examples/jpql-demo/.gitignore @@ -0,0 +1,29 @@ +HELP.md +/target/ +!.mvn/wrapper/maven-wrapper.jar + +### STS ### +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache + +### IntelliJ IDEA ### +.idea +*.iws +*.iml +*.ipr + +### NetBeans ### +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ +/build/ + +### VS Code ### +.vscode/ diff --git a/examples/jpql-demo/README.md b/examples/jpql-demo/README.md new file mode 100644 index 00000000..67632929 --- /dev/null +++ b/examples/jpql-demo/README.md @@ -0,0 +1,6 @@ +## Пример работы с JPQL + +В примере демонстрируется: +* *репозитории на Spring ORM с использованием JPA и JPQL* +* *использование JPQL для написания разного рода запросов (в т.ч. для выборки, агрегации, изменения и удаления данных)* +* *тестирование репозиториев на Spring ORM с использованием @DataJpaTest* diff --git a/examples/jpql-demo/pom.xml b/examples/jpql-demo/pom.xml new file mode 100644 index 00000000..c4b184f3 --- /dev/null +++ b/examples/jpql-demo/pom.xml @@ -0,0 +1,71 @@ + + + 4.0.0 + + + org.springframework.boot + spring-boot-starter-parent + 2.2.1.RELEASE + + + + ru.otus.example + jpql-demo + 0.0.1-SNAPSHOT + jpql-demo + Demo project for Spring Boot + + + 11 + 11 + 11 + + + + + org.springframework.boot + spring-boot-starter-data-jpa + + + + org.springframework.shell + spring-shell-starter + 2.0.1.RELEASE + + + + org.springframework.boot + spring-boot-devtools + runtime + + + + com.h2database + h2 + runtime + + + + org.projectlombok + lombok + true + + + + org.springframework.boot + spring-boot-starter-test + test + + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + + diff --git a/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/JpqlDemoApplication.java b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/JpqlDemoApplication.java new file mode 100644 index 00000000..5588b288 --- /dev/null +++ b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/JpqlDemoApplication.java @@ -0,0 +1,13 @@ +package ru.otus.example.jpql_demo; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication +public class JpqlDemoApplication { + + public static void main(String[] args) { + SpringApplication.run(JpqlDemoApplication.class, args); + } + +} diff --git a/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/dto/CitySalary.java b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/dto/CitySalary.java new file mode 100644 index 00000000..29078c2f --- /dev/null +++ b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/dto/CitySalary.java @@ -0,0 +1,15 @@ +package ru.otus.example.jpql_demo.dto; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class CitySalary { + private String city; + private Double salary; + +} diff --git a/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/dto/EmployeeProjects.java b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/dto/EmployeeProjects.java new file mode 100644 index 00000000..7f73ba5c --- /dev/null +++ b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/dto/EmployeeProjects.java @@ -0,0 +1,16 @@ +package ru.otus.example.jpql_demo.dto; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import ru.otus.example.jpql_demo.models.Employee; + + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class EmployeeProjects { + private Employee employee; + private long projectsCount; + +} diff --git a/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Address.java b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Address.java new file mode 100644 index 00000000..96a03d58 --- /dev/null +++ b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Address.java @@ -0,0 +1,24 @@ +package ru.otus.example.jpql_demo.models; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.annotations.LazyCollection; +import org.hibernate.annotations.LazyCollectionOption; + +import javax.persistence.*; +import java.util.List; + +@Data +@AllArgsConstructor +@NoArgsConstructor +@Entity +@Table(name = "addresses") +public class Address { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private long id; + + @Column(name = "city") + private String city; +} diff --git a/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Department.java b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Department.java new file mode 100644 index 00000000..79110620 --- /dev/null +++ b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Department.java @@ -0,0 +1,21 @@ +package ru.otus.example.jpql_demo.models; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.persistence.*; + +@Data +@AllArgsConstructor +@NoArgsConstructor +@Entity +@Table(name = "departments") +public class Department { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private long id; + + @Column + private String name; +} diff --git a/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Employee.java b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Employee.java new file mode 100644 index 00000000..0bcd8123 --- /dev/null +++ b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Employee.java @@ -0,0 +1,53 @@ +package ru.otus.example.jpql_demo.models; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.annotations.BatchSize; +import org.hibernate.annotations.LazyCollection; +import org.hibernate.annotations.LazyCollectionOption; + +import javax.persistence.*; +import java.math.BigDecimal; +import java.util.List; + +@Data +@AllArgsConstructor +@NoArgsConstructor +@Entity +@Table(name = "employees") +public class Employee { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private long id; + + @Column(name = "first_name") + private String firstName; + + @Column(name = "last_name") + private String lastName; + + @Column(name = "salary") + private BigDecimal salary; + + @ManyToOne + @JoinColumn(name = "department_id", referencedColumnName = "id") + private Department department; + + @ManyToOne + @JoinColumn(name = "address_id", referencedColumnName = "id") + private Address address; + + @BatchSize(size = 100) + @ManyToMany + @JoinTable(name = "employees_projects", + joinColumns = @JoinColumn(name = "employee_id", referencedColumnName = "id"), + inverseJoinColumns = @JoinColumn(name = "project_id", referencedColumnName = "id")) + private List projects; + + + public Employee(String firstName, String lastName) { + this.firstName = firstName; + this.lastName = lastName; + } +} diff --git a/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Project.java b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Project.java new file mode 100644 index 00000000..f22e4242 --- /dev/null +++ b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/models/Project.java @@ -0,0 +1,21 @@ +package ru.otus.example.jpql_demo.models; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.persistence.*; + +@Data +@AllArgsConstructor +@NoArgsConstructor +@Entity +@Table(name = "projects") +public class Project { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private long id; + + @Column(name = "name") + private String name; +} diff --git a/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/repositories/EmployeeRepository.java b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/repositories/EmployeeRepository.java new file mode 100644 index 00000000..3c00881c --- /dev/null +++ b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/repositories/EmployeeRepository.java @@ -0,0 +1,49 @@ +package ru.otus.example.jpql_demo.repositories; + +import ru.otus.example.jpql_demo.dto.CitySalary; +import ru.otus.example.jpql_demo.dto.EmployeeProjects; +import ru.otus.example.jpql_demo.models.Employee; + +import java.math.BigDecimal; +import java.util.List; +import java.util.Optional; + +public interface EmployeeRepository { + + List findAll(); + Optional findEmployeeById(long id); + List findAllEmployeesWithSalaryOver100000(); + List findEmployeesFirstNames(); + List findEmployeesFirstAndLastNames(); + long calcEmployeesCount(); + BigDecimal findMaxEmployeeSalary(); + Double calcAvgEmployeeSalary(); + + + List calcAvgSalaryByCities(); + List calcAvgSalaryByCitiesSorted(); + List calcAvgSalaryByCitiesHavingValueOver100000(); + + + List findEmployeesWithGivenProjects(String p1Name, String p2Name); + List findEmployeesProjectsCount(); + + + List findEmployeesWithGivenFirstNames(String name1, String name2); + List findEmployeesWithFirstNamesFromGivenList(List names); + List findEmployeeNameSakes(Employee employee); + + + Employee findEmployeeNameSake(Employee employee); + List findEmployeesWithSalaryLessThanGivenEmployee(Employee employee); + List findEmployeeWithNameMatchingAnyOtherEmployeesNames(); + List findEmployeesWithSalaryLessThanAllEmployees(); + + + int updateEmployeesSalary(BigDecimal oldSalary, BigDecimal newSalary); + int doubleEmployeesSalary(BigDecimal oldSalary); + int deleteEmployeesWithoutDepartment(); + + + +} diff --git a/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/repositories/EmployeeRepositoryImpl.java b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/repositories/EmployeeRepositoryImpl.java new file mode 100644 index 00000000..9cd1e495 --- /dev/null +++ b/examples/jpql-demo/src/main/java/ru/otus/example/jpql_demo/repositories/EmployeeRepositoryImpl.java @@ -0,0 +1,237 @@ +package ru.otus.example.jpql_demo.repositories; + +import org.springframework.stereotype.Repository; +import ru.otus.example.jpql_demo.dto.CitySalary; +import ru.otus.example.jpql_demo.dto.EmployeeProjects; +import ru.otus.example.jpql_demo.models.Employee; + +import javax.persistence.*; +import java.math.BigDecimal; +import java.util.List; +import java.util.Optional; + +@Repository +public class EmployeeRepositoryImpl implements EmployeeRepository { + + @PersistenceContext + private EntityManager em; + + @Override + public List findAll() { + return em.createQuery("select e from Employee e", Employee.class).getResultList(); + } + + @Override + public Optional findEmployeeById(long id) { + TypedQuery query = em.createQuery( + "select e from Employee e where e.id = :id" + , Employee.class); + query.setParameter("id", id); + try { + return Optional.of(query.getSingleResult()); + } catch (NoResultException e) { + return Optional.empty(); + } + } + + @Override + public List findAllEmployeesWithSalaryOver100000() { + return em.createQuery( + "select e from Employee e where e.salary > 100000" + , Employee.class).getResultList(); + } + + @Override + public List findEmployeesFirstNames() { + return em.createQuery( + "select e.firstName from Employee e" + , String.class).getResultList(); + } + + @SuppressWarnings("unchecked") + @Override + public List findEmployeesFirstAndLastNames() { + return em.createQuery( + "select e.firstName, e.lastName from Employee e" + ).getResultList(); + } + + @Override + public long calcEmployeesCount() { + return em.createQuery( + "select count(e) from Employee e" + , Long.class).getSingleResult(); + } + + @Override + public BigDecimal findMaxEmployeeSalary() { + return em.createQuery( + "select max(e.salary) from Employee e" + , BigDecimal.class).getSingleResult(); + } + + @Override + public Double calcAvgEmployeeSalary() { + return em.createQuery( + "select avg(e.salary) from Employee e" + , Double.class).getSingleResult(); + } + + //------------------------------------------------------------------------------------------------------- + + @Override + public List calcAvgSalaryByCities() { + return em.createQuery( + "select new ru.otus.example.jpql_demo.dto.CitySalary(e.address.city, avg(e.salary)) " + + "from Employee e " + + "group by e.address.city" + , CitySalary.class).getResultList(); + } + + @Override + public List calcAvgSalaryByCitiesSorted() { + return em.createQuery( + "select new ru.otus.example.jpql_demo.dto.CitySalary(e.address.city, avg(e.salary)) " + + "from Employee e " + + "group by e.address.city " + + "order by avg(e.salary)" + , CitySalary.class).getResultList(); + } + + @Override + public List calcAvgSalaryByCitiesHavingValueOver100000() { + return em.createQuery( + "select new ru.otus.example.jpql_demo.dto.CitySalary(e.address.city, avg(e.salary)) " + + "from Employee e " + + "group by e.address.city " + + "having avg(e.salary) > 100000" + + "order by avg(e.salary) " + , CitySalary.class).getResultList(); + } + + //------------------------------------------------------------------------------------------------------- + + @Override + public List findEmployeesWithGivenProjects(String p1Name, String p2Name) { + TypedQuery query = em.createQuery( + "select e " + + "from Employee e join e.projects p1 join e.projects p2 " + + "where p1.name = :p1 and p2.name = :p2" + , Employee.class); + query.setParameter("p1", p1Name); + query.setParameter("p2", p2Name); + return query.getResultList(); + } + + @Override + public List findEmployeesProjectsCount() { + return em.createQuery( + "select new ru.otus.example.jpql_demo.dto.EmployeeProjects(e, count(p)) " + + "from Employee e left join e.projects p " + + "group by e " + + "order by count(p) desc " + , EmployeeProjects.class).getResultList(); + } + + //------------------------------------------------------------------------------------------------------- + + @Override + public List findEmployeesWithGivenFirstNames(String name1, String name2) { + TypedQuery query = em.createQuery( + "select e " + + "from Employee e " + + "where e.firstName in (:name1, :name2) " + , Employee.class); + query.setParameter("name1", name1); + query.setParameter("name2", name2); + return query.getResultList(); + } + + @Override + public List findEmployeesWithFirstNamesFromGivenList(List names) { + TypedQuery query = em.createQuery( + "select e " + + "from Employee e " + + "where e.firstName in :names " + , Employee.class); + query.setParameter("names", names); + return query.getResultList(); + } + + @Override + public List findEmployeeNameSakes(Employee employee) { + TypedQuery query = em.createQuery( + "select e " + + "from Employee e " + + "where e.firstName in (select e2.firstName from Employee e2 where e2.lastName = :lastName and e2.id <> :id) " + , Employee.class); + query.setParameter("lastName", employee.getLastName()); + query.setParameter("id", employee.getId()); + return query.getResultList(); + } + + //------------------------------------------------------------------------------------------------------- + + @Override + public Employee findEmployeeNameSake(Employee employee) { + TypedQuery query = em.createQuery( + "select e " + + "from Employee e " + + "where e.firstName = (select e2.firstName from Employee e2 where e2.id = :id) and e.id <> :id " + , Employee.class); + query.setParameter("id", employee.getId()); + return query.getSingleResult(); + } + + @Override + public List findEmployeesWithSalaryLessThanGivenEmployee(Employee employee) { + TypedQuery query = em.createQuery( + "select e " + + "from Employee e " + + "where e.salary < (select e2.salary from Employee e2 where e2.id = :id) " + , Employee.class); + query.setParameter("id", employee.getId()); + return query.getResultList(); + } + + @Override + public List findEmployeeWithNameMatchingAnyOtherEmployeesNames() { + return em.createQuery( + "select e " + + "from Employee e " + + "where e.firstName = any(select e2.firstName from Employee e2 where e2.id <> e.id) " + , Employee.class).getResultList(); + } + + @Override + public List findEmployeesWithSalaryLessThanAllEmployees() { + return em.createQuery( + "select e " + + "from Employee e " + + "where e.salary <= all(select e2.salary from Employee e2) " + , Employee.class).getResultList(); + } + + //------------------------------------------------------------------------------------------------------- + + @Override + public int updateEmployeesSalary(BigDecimal oldSalary, BigDecimal newSalary) { + Query query = em.createQuery("update Employee e set e.salary = :newSalary where e.salary = :oldSalary"); + query.setParameter("newSalary", newSalary); + query.setParameter("oldSalary", oldSalary); + return query.executeUpdate(); + } + + @Override + public int doubleEmployeesSalary(BigDecimal oldSalary) { + Query query = em.createQuery("update Employee e set e.salary = e.salary * 2 where e.salary = :oldSalary"); + query.setParameter("oldSalary", oldSalary); + return query.executeUpdate(); + } + + @Override + public int deleteEmployeesWithoutDepartment() { + return em.createQuery("delete from Employee e where e.department is null") + .executeUpdate(); + } +} diff --git a/examples/jpql-demo/src/main/resources/application.yml b/examples/jpql-demo/src/main/resources/application.yml new file mode 100644 index 00000000..d9f3dc49 --- /dev/null +++ b/examples/jpql-demo/src/main/resources/application.yml @@ -0,0 +1,15 @@ +spring: + datasource: + url: jdbc:h2:mem:testdb + initialization-mode: always + + jpa: + generate-ddl: false + hibernate: + ddl-auto: none + + show-sql: true + properties: + hibernate: + #format_sql: true + diff --git a/examples/jpql-demo/src/main/resources/jpql.sql b/examples/jpql-demo/src/main/resources/jpql.sql new file mode 100644 index 00000000..8fcc220f --- /dev/null +++ b/examples/jpql-demo/src/main/resources/jpql.sql @@ -0,0 +1,74 @@ +select e from Employee e where e.id = :id +---------------------------------------------------------------------------------- +select e from Employee e where e.salary > 100000 +---------------------------------------------------------------------------------- +select e.firstName from Employee e +---------------------------------------------------------------------------------- +select e.firstName, e.lastName from Employee e +---------------------------------------------------------------------------------- +select count(e) from Employee e +---------------------------------------------------------------------------------- +select max(e.salary) from Employee e +---------------------------------------------------------------------------------- +select new ru.otus.example.jpql_demo.dto.CitySalary(e.address.city, avg(e.salary)) +from Employee e +group by e.address.city +---------------------------------------------------------------------------------- +select new ru.otus.example.jpql_demo.dto.CitySalary(e.address.city, avg(e.salary)) +from Employee e +group by e.address.city +order by avg(e.salary) +---------------------------------------------------------------------------------- +select new ru.otus.example.jpql_demo.dto.CitySalary(e.address.city, avg(e.salary)) +from Employee e +group by e.address.city +having avg(e.salary) > 100000 +order by avg(e.salary) +---------------------------------------------------------------------------------- +select e +from Employee e join e.projects p1 join e.projects p2 +where p1.name = :p1 and p2.name = :p2 +---------------------------------------------------------------------------------- +select new ru.otus.example.jpql_demo.dto.EmployeeProjects(e, count(p)) +from Employee e left join e.projects p +group by e +order by count(p) desc +---------------------------------------------------------------------------------- +select e +from Employee e +where e.firstName in (:name1, :name2) +---------------------------------------------------------------------------------- +select e +from Employee e +where e.firstName in :names +---------------------------------------------------------------------------------- +select e +from Employee e +where e.firstName in (select e2.firstName + from Employee e2 + where e2.lastName = :lastName and + e2.id <> :id) +---------------------------------------------------------------------------------- +select e +from Employee e +where e.firstName = (select e2.firstName + from Employee e2 + where e2.id = :id) and e.id <> :id +---------------------------------------------------------------------------------- +select e +from Employee e +where e.salary < (select e2.salary + from Employee e2 + where e2.id = :id) +---------------------------------------------------------------------------------- +select e +from Employee e +where e.firstName = any(select e2.firstName + from Employee e2 + where e2.id <> e.id) +---------------------------------------------------------------------------------- +select e +from Employee e +where e.salary <= all(select e2.salary + from Employee e2) +---------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/jpql-demo/src/main/resources/schema.sql b/examples/jpql-demo/src/main/resources/schema.sql new file mode 100644 index 00000000..f1425901 --- /dev/null +++ b/examples/jpql-demo/src/main/resources/schema.sql @@ -0,0 +1,39 @@ +DROP TABLE IF EXISTS employees_projects; +DROP TABLE IF EXISTS addresses; +DROP TABLE IF EXISTS departments; +DROP TABLE IF EXISTS projects; +DROP TABLE IF EXISTS employees; + +CREATE TABLE addresses ( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + city VARCHAR(255) +); + +CREATE TABLE departments ( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + name VARCHAR(255) +); + +CREATE TABLE projects ( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + name VARCHAR(255) +); + + +CREATE TABLE employees ( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + first_name VARCHAR(255), + last_name VARCHAR(255), + salary BIGINT, + address_id BIGINT, + department_id BIGINT, + FOREIGN KEY(address_id) REFERENCES addresses(id) ON DELETE CASCADE, + FOREIGN KEY(department_id) REFERENCES departments(id) ON DELETE CASCADE +); + +CREATE TABLE employees_projects ( + employee_id BIGINT, + project_id BIGINT, + FOREIGN KEY(employee_id) REFERENCES employees(id) ON DELETE CASCADE, + FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE CASCADE +); \ No newline at end of file diff --git a/examples/jpql-demo/src/test/java/ru/otus/example/jpql_demo/repositories/EmployeeRepositoryImplTest.java b/examples/jpql-demo/src/test/java/ru/otus/example/jpql_demo/repositories/EmployeeRepositoryImplTest.java new file mode 100644 index 00000000..f66e2b01 --- /dev/null +++ b/examples/jpql-demo/src/test/java/ru/otus/example/jpql_demo/repositories/EmployeeRepositoryImplTest.java @@ -0,0 +1,282 @@ +package ru.otus.example.jpql_demo.repositories; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; +import org.springframework.context.annotation.Import; +import ru.otus.example.jpql_demo.dto.CitySalary; +import ru.otus.example.jpql_demo.dto.EmployeeProjects; +import ru.otus.example.jpql_demo.models.Employee; + +import javax.persistence.NonUniqueResultException; +import java.math.BigDecimal; +import java.util.List; +import java.util.Optional; +import java.util.stream.IntStream; + +import static org.assertj.core.api.Assertions.*; + +@DisplayName("Репозиторий Employee должен") +@DataJpaTest +@Import(EmployeeRepositoryImpl.class) +class EmployeeRepositoryImplTest { + + private static final long FIRST_EMPLOYEE_ID = 1L; + private static final long SECOND_EMPLOYEE_ID = 2L; + private static final long THIRD_EMPLOYEE_ID = 3L; + private static final long FOURTH_EMPLOYEE_ID = 4L; + private static final long SEVENTH_EMPLOYEE_ID = 7L; + private static final long EIGTH_EMPLOYEE_ID = 8L; + + private static final int EMPLOYEES_COUNT = 8; + private static final String FIRST_EMPLOYEE_FIRST_NAME = "fn1"; + + private static final String PROJECT_3 = "Project #3"; + private static final String PROJECT_4 = "Project #4"; + + private static final CitySalary SARATOV_SALARY = new CitySalary("Saratov", 66666.0); + private static final CitySalary OMSK_SALARY = new CitySalary("Omsk", 170000.0); + private static final CitySalary MOSCOW_SALARY = new CitySalary("Moscow", 330100.0); + + private static final int MAX_SALARY = 1000000; + private static final double AVG_SALARY = 211299.75d; + private static final int EMPLOYEES_WITH_SALARY_OVER_100000_COUNT = 4; + private static final int FOURTH_EMPLOYEE_PROJECTS_COUNT = 4; + private static final String NAME_SAKE_NAME_1 = "NameSake1"; + private static final String NAME_SAKE_NAME_2 = "NameSake2"; + + @Autowired + private TestEntityManager em; + + @Autowired + private EmployeeRepositoryImpl employeeRepository; + + + @DisplayName("возвращать список всех сотрудников") + @Test + void shouldFindAllEmployees() { + List employees = employeeRepository.findAll(); + assertThat(employees).hasSize(EMPLOYEES_COUNT); + } + + @DisplayName("возвращать сотрудника по его id") + @Test + void shouldFindEmployeeById() { + Optional employee = employeeRepository.findEmployeeById(FIRST_EMPLOYEE_ID); + assertThat(employee).isNotEmpty().get() + .hasFieldOrPropertyWithValue("firstName", FIRST_EMPLOYEE_FIRST_NAME); + } + + @DisplayName("возвращать список всех сотрудников c окладом более 100000") + @Test + void shouldFindAllEmployeesWithSalaryOver100000() { + List allEmployeesWithSalaryOver100000 = employeeRepository.findAllEmployeesWithSalaryOver100000(); + assertThat(allEmployeesWithSalaryOver100000).size().isEqualTo(EMPLOYEES_WITH_SALARY_OVER_100000_COUNT); + } + + @DisplayName("возвращать список имен всех сотрудников") + @Test + void shouldFindEmployeesFirstNames() { + List employeesFirstNames = employeeRepository.findEmployeesFirstNames(); + assertThat(employeesFirstNames) + .containsExactlyInAnyOrder("fn1", "fn2", "fn3", "fn4", "fn5", "fn6", "fn7", "fn8"); + } + + @DisplayName("возвращать список имен и фамилий всех сотрудников") + @Test + void shouldFindEmployeesFirstAndLastNames() { + List employeesFirstAndLastNames = employeeRepository.findEmployeesFirstAndLastNames(); + String[][] expectedFirstAndLastNames = new String[EMPLOYEES_COUNT][2]; + IntStream.range(1, EMPLOYEES_COUNT + 1) + .forEachOrdered(i -> expectedFirstAndLastNames[i - 1] = new String[]{"fn" + i, "ln" + i}); + assertThat(employeesFirstAndLastNames).containsExactlyInAnyOrder(expectedFirstAndLastNames); + } + + @DisplayName("считать общее количество сотрудников") + @Test + void shouldCalcEmployeesCount() { + long employeesCount = employeeRepository.calcEmployeesCount(); + assertThat(employeesCount).isEqualTo(EMPLOYEES_COUNT); + } + + @DisplayName("находить максимальный оклад сотрудников") + @Test + void shouldFindMaxEmployeeSalary() { + BigDecimal maxSalary = employeeRepository.findMaxEmployeeSalary(); + assertThat(maxSalary).isEqualTo(new BigDecimal(MAX_SALARY)); + } + + @DisplayName("считать средний оклад всех сотрудников") + @Test + void shouldCalcAvgEmployeeSalary() { + Double avgSalary = employeeRepository.calcAvgEmployeeSalary(); + assertThat(avgSalary).isEqualTo(AVG_SALARY, offset(0.01d)); + } + + //------------------------------------------------------------------------------------------------------- + + @DisplayName("возвращать список окладов по городам") + @Test + void shouldCalcAvgEmployeeSalaryByCities() { + List avgSalaryByCities = employeeRepository.calcAvgSalaryByCities(); + assertThat(avgSalaryByCities) + .containsExactlyInAnyOrder(SARATOV_SALARY, MOSCOW_SALARY, OMSK_SALARY); + } + + @DisplayName("возвращать сортированный список окладов по городам") + @Test + void shouldCalcAvgEmployeeSalaryByCitiesSorted() { + List avgSalaryByCities = employeeRepository.calcAvgSalaryByCitiesSorted(); + assertThat(avgSalaryByCities) + .containsExactly(SARATOV_SALARY, OMSK_SALARY, MOSCOW_SALARY); + } + + @DisplayName("возвращать список окладов по городам, где средний доход сотрудников более 100000") + @Test + void shouldCalcAvgEmployeeSalaryByCitiesHavingValueOver100000() { + List avgSalaryByCities = employeeRepository.calcAvgSalaryByCitiesHavingValueOver100000(); + assertThat(avgSalaryByCities).containsExactly(OMSK_SALARY, MOSCOW_SALARY); + } + + //------------------------------------------------------------------------------------------------------- + + @DisplayName("возвращать список всех сотрудников работающих над заданными проектами") + @Test + void shouldFindEmployeesWithGivenProjects() { + Employee employee2 = em.find(Employee.class, SECOND_EMPLOYEE_ID); + Employee employee4 = em.find(Employee.class, FOURTH_EMPLOYEE_ID); + List employees = employeeRepository.findEmployeesWithGivenProjects(PROJECT_3, PROJECT_4); + assertThat(employees).hasSize(2).containsExactlyInAnyOrder(employee2, employee4); + } + + @DisplayName("возвращать количество проектов по сотрудникам") + @Test + void shouldFindEmployeesProjectsCount() { + Employee employee4 = em.find(Employee.class, FOURTH_EMPLOYEE_ID); + List employeeProjects = employeeRepository.findEmployeesProjectsCount(); + assertThat(employeeProjects).hasSize(EMPLOYEES_COUNT) + .contains(new EmployeeProjects(employee4, FOURTH_EMPLOYEE_PROJECTS_COUNT)); + } + + //------------------------------------------------------------------------------------------------------- + + @DisplayName("возвращать список всех сотрудников имеющих одно из двух заданных имен") + @Test + void shouldFindEmployeesWithGivenFirstNames() { + Employee employee1 = em.find(Employee.class, FIRST_EMPLOYEE_ID); + Employee employee7 = em.find(Employee.class, SEVENTH_EMPLOYEE_ID); + List employees = employeeRepository.findEmployeesWithGivenFirstNames("fn1", "fn7"); + assertThat(employees).hasSize(2).containsExactlyInAnyOrder(employee1, employee7); + } + + @DisplayName("возвращать список всех сотрудников имеющих имя, совпадающиее с одним из заданного списка") + @Test + void shouldFindEmployeesWithFirstNamesFromGivenList() { + Employee employee1 = em.find(Employee.class, FIRST_EMPLOYEE_ID); + Employee employee7 = em.find(Employee.class, SEVENTH_EMPLOYEE_ID); + List employees = employeeRepository.findEmployeesWithFirstNamesFromGivenList(List.of("fn1", "fn7")); + assertThat(employees).hasSize(2).containsExactlyInAnyOrder(employee1, employee7); + } + + @DisplayName("возвращать список всех однофамильцев заданного сотрудника") + @Test + void shouldFindEmployeesNameSakes() { + Employee employee1 = em.find(Employee.class, FIRST_EMPLOYEE_ID); + Employee employee9 = em.persistAndFlush(new Employee(NAME_SAKE_NAME_1, employee1.getLastName())); + Employee employee10 = em.persistAndFlush(new Employee(NAME_SAKE_NAME_2, employee1.getLastName())); + List nameSakes = employeeRepository.findEmployeeNameSakes(employee1); + assertThat(nameSakes).hasSize(2).containsExactlyInAnyOrder(employee9, employee10); + } + + //------------------------------------------------------------------------------------------------------- + + @DisplayName("возвращать список всех тезок заданного сотрудника") + @Test + void shouldFindEmployeeNameSake() { + Employee employee1 = em.find(Employee.class, FIRST_EMPLOYEE_ID); + Employee employee9 = em.persistAndFlush(new Employee(employee1.getFirstName(), NAME_SAKE_NAME_1)); + Employee nameSake = employeeRepository.findEmployeeNameSake(employee1); + assertThat(nameSake).isEqualToComparingFieldByField(employee9); + + em.persistAndFlush(new Employee(employee1.getFirstName(), NAME_SAKE_NAME_2)); + assertThatCode(() -> employeeRepository.findEmployeeNameSake(employee1)) + .isInstanceOf(NonUniqueResultException.class); + } + + @DisplayName("возвращать список всех сотрудников имеющих оклад меньше, чем у заданного сотрудника") + @Test + void shouldFindEmployeesWithSalaryLessThanGivenEmployee() { + Employee employee1 = em.find(Employee.class, FIRST_EMPLOYEE_ID); + Employee employee2 = em.find(Employee.class, SECOND_EMPLOYEE_ID); + Employee employee3 = em.find(Employee.class, THIRD_EMPLOYEE_ID); + Employee employee7 = em.find(Employee.class, SEVENTH_EMPLOYEE_ID); + List employees = employeeRepository.findEmployeesWithSalaryLessThanGivenEmployee(employee7); + assertThat(employees).hasSize(3).containsExactlyInAnyOrder(employee1, employee2, employee3); + } + + @DisplayName("возвращать сотрудника, являющегося тезкой любому другому сотруднику") + @Test + void shouldFindEmployeeWithNameMatchingAnyOtherEmployeesNames() { + Employee employee1 = em.find(Employee.class, FIRST_EMPLOYEE_ID); + Employee employee9 = em.persistAndFlush(new Employee(employee1.getFirstName(), NAME_SAKE_NAME_1)); + List nameSakes = employeeRepository.findEmployeeWithNameMatchingAnyOtherEmployeesNames(); + assertThat(nameSakes).hasSize(2).containsExactlyInAnyOrder(employee9, employee1); + } + + @DisplayName("возвращать сотрудника имеющго оклад меньше, чем у всех") + @Test + void shouldFindEmployeesWithSalaryLessThanAllEmployees() { + Employee employee3 = em.find(Employee.class, THIRD_EMPLOYEE_ID); + List employees = employeeRepository.findEmployeesWithSalaryLessThanAllEmployees(); + assertThat(employees).hasSize(1).containsOnly(employee3); + + } + + //------------------------------------------------------------------------------------------------------- + + @DisplayName("изменять значение оклада сотрудника имеющго заданный оклад") + @Test + void shouldUpdateEmployeesSalary() { + Employee employee3 = em.find(Employee.class, THIRD_EMPLOYEE_ID); + BigDecimal oldSalary = employee3.getSalary(); + BigDecimal newSalary = oldSalary.multiply(new BigDecimal(2)); + em.detach(employee3); + employeeRepository.updateEmployeesSalary(oldSalary, newSalary); + + employee3 = em.find(Employee.class, THIRD_EMPLOYEE_ID); + assertThat(employee3.getSalary()).isEqualTo(newSalary); + } + + @DisplayName("изменять значение оклада в два раза, у сотрудника имеющго заданный оклад") + @Test + void shouldDoubleEmployeesSalary() { + Employee employee3 = em.find(Employee.class, THIRD_EMPLOYEE_ID); + BigDecimal oldSalary = employee3.getSalary(); + BigDecimal newSalary = oldSalary.multiply(new BigDecimal(2)); + em.detach(employee3); + employeeRepository.doubleEmployeesSalary(oldSalary); + + employee3 = em.find(Employee.class, THIRD_EMPLOYEE_ID); + assertThat(employee3.getSalary()).isEqualTo(newSalary); + } + + @DisplayName("удалять сотрудников не относящихся ни к одному отделу") + @Test + void shouldDeleteEmployeesWithoutDepartment() { + Employee employee2 = em.find(Employee.class, SECOND_EMPLOYEE_ID); + Employee employee8 = em.find(Employee.class, EIGTH_EMPLOYEE_ID); + assertThat(employee2).isNotNull(); + assertThat(employee8).isNotNull(); + employeeRepository.deleteEmployeesWithoutDepartment(); + + em.clear(); + + employee2 = em.find(Employee.class, SECOND_EMPLOYEE_ID); + employee8 = em.find(Employee.class, EIGTH_EMPLOYEE_ID); + assertThat(employee2).isNull(); + assertThat(employee8).isNull(); + } + +} \ No newline at end of file diff --git a/examples/jpql-demo/src/test/resources/application.yml b/examples/jpql-demo/src/test/resources/application.yml new file mode 100644 index 00000000..30cb8ab6 --- /dev/null +++ b/examples/jpql-demo/src/test/resources/application.yml @@ -0,0 +1,16 @@ +spring: + datasource: + url: jdbc:h2:mem:testdb + initialization-mode: always + data: test-data.sql + + jpa: + generate-ddl: false + hibernate: + ddl-auto: none + + show-sql: true + properties: + hibernate: + #format_sql: true + diff --git a/examples/jpql-demo/src/test/resources/test-data.sql b/examples/jpql-demo/src/test/resources/test-data.sql new file mode 100644 index 00000000..6ac15df5 --- /dev/null +++ b/examples/jpql-demo/src/test/resources/test-data.sql @@ -0,0 +1,21 @@ +INSERT INTO addresses (city) VALUES ('Saratov'), ('Omsk'), ('Moscow'); +INSERT INTO departments (name) VALUES ('IT'), ('AHO'); +INSERT INTO projects (name) VALUES ('Project #1'), ('Project #2'), ('Project #3'), ('Project #4'); + +INSERT INTO employees (first_name, last_name, salary, address_id, department_id) +VALUES ('fn1', 'ln1', 70000, 1, 1), + ('fn2', 'ln2', 99998, 1, null), + ('fn3', 'ln3', 30000, 1, 2), + + ('fn4', 'ln4', 170000, 2, 1), + + ('fn5', 'ln5', 120000, 3, 1), + ('fn6', 'ln6', 100400, 3, 1), + ('fn7', 'ln7', 100000, 3, 1), + ('fn8', 'ln8', 1000000, 3, null); + + +INSERT INTO employees_projects (employee_id, project_id) +VALUES (1, 1), (1, 2), (1, 3), + (2, 3), (2, 4), + (4, 1), (4, 2), (4, 3), (4, 4); \ No newline at end of file