Implementation of scenario 8 + improvements of names of several methods in the DataRepository interface

Author: bwajtr

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 bwajtr
+Copyright (c) 2016 Bretislav Wajtr
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

dbscenarios.txt

@@ -5,7 +5,7 @@
 5. Update single existing entity - update all fields of entity at once
 6. Fetch entity and it's many-to-one relation (Company for Department)
 7. Fetch entity and it's one-to-many relation (Departments for Company)
-8. Update entitie's one-to-many relation - add two items, update two items and delete one item
+8. Update entities one-to-many relation - add two items, update two items and delete one item
 9. Complex select - construct select where conditions based on some boolean conditions + throw in some outer joins
 10. Transactions handling
 11. Call stored procedure

pom.xml

@@ -41,15 +41,22 @@
         <dependency>
             <groupId>org.postgresql</groupId>
             <artifactId>postgresql</artifactId>
-            <version>9.4-1201-jdbc41</version>
-            <scope>runtime</scope>
+            <version>9.4.1211.jre7</version>
         </dependency>
 
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
             <version>3.4</version>
         </dependency>
+
+        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>4.1</version>
+        </dependency>
+
     </dependencies>
 
     <build>

sql-updates/create-script.sql

@@ -1,4 +1,4 @@
--- Meant for PostgreSQL --
+-- Meant for PostgreSQL 9.5  --
 
 -- (re)create tables first
 
@@ -53,6 +53,7 @@ INSERT INTO Department (company_pid, name) VALUES (1, 'Software Development');
 INSERT INTO Department (company_pid, name) VALUES (2, 'Help desk');
 INSERT INTO Department (company_pid, name) VALUES (2, 'Sales');
 INSERT INTO Department (company_pid, name) VALUES (3, 'Hardware Development');
+INSERT INTO Department (company_pid, name) VALUES (1, 'Lazy Department');
 
 -- names generated using listofrandomnames.com ;)
 INSERT INTO Employee (department_pid, name, surname, email, salary)

src/main/java/com/clevergang/dbtests/Scenarios.java

@@ -1,20 +1,23 @@
 package com.clevergang.dbtests;
 
-import java.math.BigDecimal;
-import java.time.LocalDate;
-import java.util.ArrayList;
-import java.util.List;
-
 import com.clevergang.dbtests.model.Company;
 import com.clevergang.dbtests.model.Department;
 import com.clevergang.dbtests.model.Employee;
 import com.clevergang.dbtests.model.Project;
 import com.clevergang.dbtests.repository.DataRepository;
+import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.util.StopWatch;
 
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static java.util.stream.Collectors.toList;
+
 /**
  * Common scenarios
  *
@@ -70,7 +73,7 @@ public void scenarioFour() {
             project.setDate(LocalDate.now());
             projects.add(project);
         }
-        repository.insertAllProjects(projects);
+        repository.insertProjects(projects);
         watch.stop();
         logger.info("Total time {} ms", watch.getTotalTimeMillis());
     }
@@ -121,15 +124,88 @@ public void scenarioSeven() {
         // a lazy select is issued and Departments are fetched from DB. However you can also use EAGER FetchType strategy which
         // causes the relation to load along with the primary entity - this behavior is (by our opinion) the source of all evil
         // in JPA... So, in non-JPA approach, we don't have any "eager" loads, just explicit calls for data:
-        List<Department> departments = repository.getDepartmentsForCompany(company.getPid());
+        List<Department> departments = repository.findDepartmentsOfCompany(company);
 
         logger.info("There are {} departments in {} company", departments.size(), company.getName());
     }
 
+    /**
+     * Update one-to-many relation (Departments in Company) at once - add two items, update one items and delete one item.
+     * <br/>
+     * This scenario covers situation where we have no idea what operations were performed by the user. We only
+     * have new list of Departments and we have to efficiently update DB so it exactly reflects new Departments list.
+     * <br/>
+     * At the same time, we DON'T want to take the tempting path and do it by "removing all the existing departments of the company from
+     * database and then inserting new values". This is actually not what the user did nor it's what we should do -> what if the departments
+     * which were only updated have some additional relations in the database? -> if we delete them, we will delete also those relations ->
+     * always ask yourself if this is something you want (or you want risk).
+     */
     public void scenarioEight() {
+        Company company = repository.findCompany(1); // Clevergang company
+
+        // this call simulates what typically happens in UI - the user chooses new list of departments for company
+        // (adds new ones, updates some other or removes some departments). The new list is transferred from
+        // UI to business service a List<Department> with no information about what departments were deleted or which
+        // ones were updated - the business service has to determine these changes - which is what rest of the code in this method does
+        List<Department> newDepartments = createNewDepartmentsList(company);
+
+        updateDepartments(company, newDepartments);
 
+        // now check the results
+        List<Department> departmentsForCompany = repository.findDepartmentsOfCompany(company);
+        logger.info("State of database at the end of scenario eight: {}", departmentsForCompany);
+    }
+
+    private void updateDepartments(Company company, List<Department> newDepartments) {
+        // --------------------------------------------------------------------------------------------------------------------------------------
+        // The pattern for one-to-many relation update begins here - but BEWARE, it'll work nicely only for few items in the one to many relation
+        // --------------------------------------------------------------------------------------------------------------------------------------
+
+        // first get current departments
+        List<Department> currentDepartments = repository.findDepartmentsOfCompany(company);
+
+        // now determine which departments were deleted
+        Collection<Integer> newPIDs = CollectionUtils.collect(newDepartments, Department::getPid);
+        List<Department> deletedDepartments = currentDepartments.stream()
+                .filter(department -> !newPIDs.contains(department.getPid()))
+                .collect(toList());
+
+        // ... and which were added or updated
+        Map<Boolean, List<Department>> addedOrUpdatedDepartments = newDepartments.stream()
+                .filter(department -> !currentDepartments.contains(department))  // filtering out not changed items, assumes that equals and hashCode is properly coded in Department class
+                .collect(Collectors.partitioningBy(d -> d.getPid() == null));  // split (partition) by new or updated (pid is either null or not)
+        List<Department> addedDepartments = addedOrUpdatedDepartments.get(Boolean.TRUE);
+        List<Department> updatedDepartments = addedOrUpdatedDepartments.get(Boolean.FALSE);
+
+        // now perform relevant operations on each list:
+        repository.deleteDepartments(deletedDepartments);
+        repository.insertDepartments(addedDepartments);
+        repository.updateDepartments(updatedDepartments);
+    }
+
+    private List<Department> createNewDepartmentsList(Company company) {
+        List<Department> departments = repository.findDepartmentsOfCompany(company);
+
+        // delete one item
+        departments.removeIf(department -> department.getName().equals("Lazy Department"));
+
+        // add two items (notice they don't have thier own pid yet)
+        departments.add(new Department(company.getPid(), "New department 1"));
+        departments.add(new Department(company.getPid(), "New department 2"));
+
+        // update one item
+        Optional<Department> itDepartment = departments.stream()
+                .filter(it -> it.getName().equals("IT Department"))
+                .findFirst();
+
+        if (itDepartment.isPresent()) {
+            itDepartment.get().setName("IT Department Updated");
+        }
+
+        return departments;
     }
 }
 
 
 
+

src/main/java/com/clevergang/dbtests/model/Department.java

@@ -32,6 +32,14 @@ public void setCompanyPid(Integer company_pid) {
         this.company_pid = company_pid;
     }
 
+    public Department() {
+    }
+
+    public Department(Integer company_pid, String name) {
+        this.company_pid = company_pid;
+        this.name = name;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o)

src/main/java/com/clevergang/dbtests/repository/DataRepository.java

@@ -1,12 +1,12 @@
 package com.clevergang.dbtests.repository;
 
-import java.util.List;
-
 import com.clevergang.dbtests.model.Company;
 import com.clevergang.dbtests.model.Department;
 import com.clevergang.dbtests.model.Employee;
 import com.clevergang.dbtests.model.Project;
 
+import java.util.List;
+
 /**
  * In "normal" application we would rather split the repository to multiple classes based on entity
  * we want to work with (CompanyRepository, DepartmentRepository etc.). We decided
@@ -16,17 +16,32 @@
  */
 public interface DataRepository {
 
+    // companies
+
     Company findCompany(Integer pid);
 
+    // departments
+
     Department findDepartment(Integer pid);
 
-    List<Employee> employeesWithSalaryGreaterThan(Integer minSalary);
+    List<Department> findDepartmentsOfCompany(Company company);
+
+    void deleteDepartments(List<Department> departmentsToDelete);
+
+    void updateDepartments(List<Department> departmentsToUpdate);
+
+    void insertDepartments(List<Department> departmentsToInsert);
+
+    // projects
 
     Integer insertProject(Project project);
 
-    List<Integer> insertAllProjects(List<Project> projects);
+    List<Integer> insertProjects(List<Project> projects);
+
+    // employees
+
+    List<Employee> employeesWithSalaryGreaterThan(Integer minSalary);
 
     void updateEmployee(Employee employeeToUpdate);
 
-    List<Department> getDepartmentsForCompany(Integer pid);
 }