Hibernate Interview Questions

1. filter employees with same salary count greater than five (group by salary) using hibernate criteria?
1. Session session = getCurrentSession(); ProjectionList projectionList = Projections.projectionList(); projectionList.add(Projections.groupProperty("totalCode")) .add(Projections.groupProperty("activityCode")) .add(Projections.sum("amount")) .add(Projections.rowCount()); Criteria criteria = session.createCriteria(Payment.class); criteria.setProjection(projectionList); List payments = criteria.list(); for (Object[] payment : payments) { System.out.println("totalCode: " + payment[0]); System.out.println("activityCode: " + payment[1]); System.out.println("amountSum: " + payment[2]); System.out.println("rowCount: " + payment[3]); }
2. What is Hibernate N+1 Problems and its Solution?
1. Hibernate n+1 problems only comes for one to many relationship.
2. Let us see this problem by example – We have Department table with a one-to-many relationship with Employee. One Department may have many Employees.
3. We have written the Hibernate Department Entity as below.
4. @Entity public class Department { private Long id; @OneToMany private Employee[] Employees; }
5. So now you want to print out all the details of Employee models. A native O/R implementation would SELECT all Department and then do N additional SELECTs for getting the information of Employee for each department.
6. -- To Get all Departments SELECT * FROM Department; -- To get each Employee, get Employee details SELECT * FROM Employee WHERE Employee.departmentId = ?
7. As you see, the N+1 problem can happen if the first query populates the primary object and the second query populates all the child objects for each of the unique primary objects returned.
8. Solution for Hibernate N+1 Problem
1. Using HQL fetch join
1. You can use the fetch while using the HQL as below example.
1. from Department d join fetch d.employees Employee
2. Hibernate Generated SQL would be similer as –
3. SELECT * FROM Department d LEFT OUTER JOIN Employee e ON d.id = d.department_id
1. Using Criteria query
1. Criteria criteria = session.createCriteria(Department.class); criteria.setFetchMode("employees", FetchMode.EAGER);
2. In both above cases, the query returns a list of Department objects with the Employee initialized, and only one query needs to be run to return all the Department and Employee information required.

Continue Reading

Hibernate one to one mapping

1. In this kind of association, a foreign key column is created in owner entity. For example, if we make EmployeeEntity owner, then a extra column "ACCOUNT_ID" will be created in Employee table. This column will store the foreign key for Account table.
2. To make such association, refer the Account entity in EmployeeEntity class as follow:
3. @OneToOne @JoinColumn(name="ACCOUNT_ID") private AccountEntity account;
4. @JoinColumn
2. The join column is declared with the @JoinColumn annotation which looks like the @Column annotation, It is used in column owner column and mapped by used in other table. It has one more parameters named referencedColumnName. This parameter declares the column in the targeted entity that will be used to the join.
5. mappedBy
1.  mappedBy is used. ‘mappedBy’ refers to the property name of the association on the owner side.AccountEntity.java
2. @OneToOne(mappedBy="account") private EmployeeEntity employee;
3. 
   

Continue Reading

Hibernate Many-To-One Bidirectional

1. One table has a foreign key column that references the primary key of associated table.In Bidirectional relationship, both side navigation is possible.
2. We are discussing an example of Student and University relationship. Many student can enroll at one University. And one University can have many students. 
3. @Entity @Table(name = "STUDENT") public class Student { @Id @GeneratedValue @Column(name = "STUDENT_ID") private long id; @Column(name = "FIRST_NAME") private String firstName; @ManyToOne(optional = false) @JoinColumn(name = "UNIVERSITY_ID") private University university; ------------------------ ------------------------ } @Entity @Table(name = "UNIVERSITY") public class University { @Id @GeneratedValue @Column(name = "UNIVERSITY_ID") private long id; @Column(name = "NAME") private String name; @Column(name = "COUNTRY") private String country; @OneToMany(mappedBy = "university", cascade = CascadeType.ALL) private List students; }
4. @JoinColumn says that Student table will contain a separate column UNIVERSITY_ID which will eventually act as a foreign key reference to primary key of University table

Continue Reading

Many to Many Annotation

1. In this scenario, any given employee can be assigned to multiple projects and a project may have multiple employees working for it, leading to a many-to-many association between the two.
2. We have an employee table with employee_id as its primary key and a project table with project_id as its primary key. A join table employee_project is required here to connect both sides.
3. The model classes Employee and Project need to be created with JPA annotations:
1. @Entity @Table(name = "Employee") public class Employee { // ... @ManyToMany(cascade = { CascadeType.ALL }) @JoinTable( name = "Employee_Project", joinColumns = { @JoinColumn(name = "employee_id") }, inverseJoinColumns = { @JoinColumn(name = "project_id") } ) Set projects = new HashSet<>(); // standard constructor/getters/setters } @Entity @Table(name = "Project") public class Project { // ... @ManyToMany(mappedBy = "projects") private Set employees = new HashSet<>(); // standard constructors/getters/setters }
4. Both the Employee class and Project classes refer to one another, which means that the association between them is bidirectional.
5. In order to map a many-to-many association, we use the @ManyToMany, @JoinTable and @JoinColumn annotations. 
6. @ManyToMany
1. The @ManyToMany annotation is used in both classes to create the many-to-many relationship between the entities.
7. @JoinTable
1.  In our example, the owning side is Employee so the join table is specified on the owning side by using the @JoinTable annotation in Employee class
8. @JoinColumn
1. The @JoinColumn annotation is used to specify the join/linking column with the main table. Here, the join column is employee_id and project_id is the inverse join column since Project is on the inverse side of the relationship
9. mappedBy
1. In the Project class, the mappedBy attribute is used in the @ManyToMany annotation to indicate that the employees collection is mapped by the projects collection of the owner side

Continue Reading