Spring Data JPA Test 2

What happens when the following code executes?

Student student = new Student();
student.setId(1L);
student.setName("Alex");
entityManager.persist(student);

Which cascade type ensures that when a parent entity is removed, its related child entities are also deleted?

Which of the following is a valid Spring Data JPA derived query method?

What will happen in the following mapping?

@Entity
public class Employee {
    @ManyToOne(fetch = FetchType.EAGER)
    private Department department;
}

Which propagation type ensures that if a transaction already exists, the method joins it; otherwise, a new one is created?

What does entityManager.merge(entity) do in JPA?

What is the default fetch type for a @OneToMany relationship in JPA?

@OneToMany(mappedBy = "department")
private List<Employee> employees;

What is the purpose of Pageable in the following repository method?

Page<Student> findByDepartment(String department, Pageable pageable);

What is the N+1 problem in JPA/Hibernate?

What happens in this case?

@Transactional
public void processOrder() {
    saveOrder();  // REQUIRED
    saveAudit();  // REQUIRES_NEW
}

What will happen when this code executes?

Student student = entityManager.find(Student.class, 1L);
entityManager.remove(student);

In a bidirectional relationship, why is the mappedBy attribute important?

Which of the following is required when executing update or delete queries with @Query?

What performance issue will occur here if `employees` is `LAZY`?

List<Department> departments = departmentRepo.findAll();
for (Department dept : departments) {
    System.out.println(dept.getEmployees().size());
}

Which isolation level prevents dirty reads but allows non-repeatable reads?

What is the role of the @Table annotation in JPA?

What happens when orphanRemoval = true is set on a relationship?

What does the following method do?

@Modifying
@Transactional
@Query("UPDATE Employee e SET e.salary = e.salary * 1.1 WHERE e.department = ?1")
int increaseSalaryByDept(String department);

Which query strategy can help avoid the N+1 problem?

What effect does @Transactional(readOnly = true) have?

@Transactional(readOnly = true)
public List<User> getAllUsers() {
    return userRepo.findAll();
}