Spring Data JPA Test 1

What is the main purpose of Hibernate ORM in a Spring Data JPA context?

Which of the following best describes a @OneToOne relationship in JPA?

Which statement correctly describes the relationship between CrudRepository and JpaRepository?

What is the default fetch type for `@ManyToOne` and `@OneToOne` relationships in JPA?

What is the primary purpose of the @Transactional annotation in Spring Data JPA?

Which annotation is used to mark a class as a JPA entity in Hibernate ORM?

What does the following mapping represent?

@Entity
public class Department {
    @Id
    private Long id;

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

What will the following repository provide?

public interface StudentRepository extends CrudRepository<Student, Long> {
}

What is the default fetch type for `@OneToMany` and `@ManyToMany` associations?

By default, @Transactional in Spring rolls back on which type of exceptions?

What will the following entity map to in the database?

@Entity
@Table(name = "students")
public class Student {
    @Id
    private Long id;
    private String name;
}

In JPA, what is the typical use of @ManyToOne annotation?

Which repository interface provides built-in methods for pagination and sorting?

What happens when accessing `department.getEmployees()` if `employees` is mapped as `LAZY`?

@Entity
public class Department {
    @OneToMany(mappedBy = "department", fetch = FetchType.LAZY)
    private List<Employee> employees;
}

What will happen to the database changes in the following method?

@Transactional
public void saveData() {
    userRepo.save(new User("John"));
    if (true) {
        throw new RuntimeException("Failure!");
    }
}

Which of the following is not a valid JPA entity lifecycle state?

What is the effect of the following mapping?

@Entity
public class Student {
    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses;
}

What does the following method do?

public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    @Query("SELECT e FROM Employee e WHERE e.department = ?1")
    List<Employee> findByDepartment(String department);
}

When does a `LazyInitializationException` occur in JPA/Hibernate?

What will happen in this case?

@Transactional
public void saveData() throws IOException {
    userRepo.save(new User("Alice"));
    throw new IOException("Checked Exception!");
}