>Digital-flame

Lazy loading in Hibernate means delaying the retrieval of an associated entity or collection from the database until it’s actually accessed in your code.
It helps avoid unnecessary database queries and improves performance by loading only what you need, when you need it.

🔹 How does it work?

• When you fetch an entity with lazy-loaded associations, Hibernate initially loads only the entity itself.
• The associated entities or collections are represented as proxies — lightweight placeholders.
• The first time you access a lazy association, Hibernate triggers an SQL query to load the actual data.

🔹 Why use lazy loading?
✅ Performance → avoids loading large graphs of related entities you might never use.
✅ Efficiency → reduces initial SQL queries, memory usage, and network traffic.

🔹 How to enable lazy loading:
Hibernate uses lazy loading by default for most associations:

• @OneToMany and @ManyToMany → lazy by default.
• @ManyToOne and @OneToOne → eager by default (but can be changed).

You explicitly control fetch strategy with the fetch attribute:

@OneToMany(fetch = FetchType.LAZY)
private List<Order> orders;

🔹 Example:

Session session = sessionFactory.openSession();

User user = session.get(User.class, 1L); // loads User only

// At this point, user.getOrders() is not yet loaded from DB!

List<Order> orders = user.getOrders();  // triggers SQL SELECT when accessed

session.close();

🔹 What happens behind the scenes?

• Hibernate creates a proxy for user.getOrders().
• When you call user.getOrders() for the first time, Hibernate issues an SQL query like:

SELECT * FROM orders WHERE user_id = ?

🔹 Important caution: LazyInitializationException
✅ If you access a lazy-loaded association after the session is closed, you’ll get LazyInitializationException, because Hibernate can’t fetch data outside an active session.

Example problematic case:

User user = session.get(User.class, 1L);
session.close();
List<Order> orders = user.getOrders(); // 💥 throws LazyInitializationException

✅ Key takeaway:
Lazy loading in Hibernate defers loading of associations until they’re accessed, boosting performance by avoiding unnecessary data loading — but requires careful session management to avoid LazyInitializationException.

You annotate a field or getter in your entity class with @Id. Hibernate maps this to the primary key column in the database.

🔹 Basic example:

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // auto-increment PK
    private Long id;

    private String username;

    // getters and setters
}

✅ Here:

• The id field is the primary key, defined with @Id.
• @GeneratedValue(...) tells Hibernate how to generate the key (e.g., identity, sequence, UUID).

🔹 Primary key options in Hibernate:
✅ Simple primary key → one column mapped with @Id.
✅ Composite primary key → multiple columns combined, mapped with:

• @Embeddable + @EmbeddedId → recommended modern approach.
• Or @IdClass → alternative but more verbose.

🔹 Composite key example:

@Embeddable
public class EnrollmentId implements Serializable {
    private Long studentId;
    private Long courseId;
}

@Entity
public class Enrollment {
    @EmbeddedId
    private EnrollmentId id;

    private String grade;
}

🔹 Important notes:
✅ You must define a primary key in every JPA/Hibernate entity → Hibernate requires it to track entities.
✅ Without a primary key, Hibernate can’t map objects reliably → you’ll get errors at runtime.

✅ Key takeaway:
A primary key is a unique, non-null identifier for your entity’s rows.
In Hibernate, you define it with @Id (and optionally @GeneratedValue) or use @EmbeddedId/@IdClass for composite keys.

✅ When a primary key is composite, it means it consists of two or more columns together forming the unique identifier → no single column is enough to uniquely identify the row, but the combination is.

🔹 How does a composite primary key look in SQL?

Example: Suppose you have an enrollment table representing students enrolled in courses. The combination of student_id and course_id uniquely identifies each enrollment:

CREATE TABLE enrollment (
  student_id BIGINT NOT NULL,
  course_id BIGINT NOT NULL,
  enrollment_date DATE,
  grade VARCHAR(10),
  PRIMARY KEY (student_id, course_id), -- composite primary key
  FOREIGN KEY (student_id) REFERENCES student(id),
  FOREIGN KEY (course_id) REFERENCES course(id)
);

🔹 What does it mean?
✅ Neither student_id nor course_id alone guarantees uniqueness.
✅ But together (student_id, course_id) ensures one student can enroll only once in a given course, avoiding duplicate enrollments.

🔹 How does the database enforce it?

• The DBMS creates a unique index on the pair (student_id, course_id) → duplicate combinations are rejected.
• Both columns are marked as not null, since primary key columns cannot contain nulls.

🔹 What does the data look like?

✅ You can see student_id=1 can appear multiple times, but never twice with the same course_id.

🔹 How do you map this in Hibernate?
Using @EmbeddedId or @IdClass

🔹 Example composite PK class for Hibernate with @Embeddable:

@Embeddable
public class EnrollmentId implements Serializable {
    private Long studentId;
    private Long courseId;
    // equals() and hashCode() required
}

And entity:

@Entity
public class Enrollment {
    @EmbeddedId
    private EnrollmentId id;
    private String grade;
}

✅ Key takeaway:
A composite primary key uses two or more columns together as the unique identifier, ensuring no duplicates of the combination — it’s common for join or link tables representing many-to-many relationships (e.g., enrollment).

🔹 1) Uniqueness guarantee

• A primary key enforces uniqueness → ensures every row has a unique identifier → no duplicates allowed in primary key columns.

🔹 2) Non-nullability

• A primary key cannot be NULL → every row must have a defined key value → no missing identifiers.

🔹 3) Referential integrity

• When you use a primary key as the target of a foreign key, the database enforces consistency:
  • Foreign keys can only point to existing primary key values.
  • Prevents orphaned rows (e.g., an order referencing a non-existent customer).
  • Ensures safe cascading deletes or updates.

🔹 4) Consistent identity

• A primary key gives your application a stable, unique way to identify each row for updates, deletes, or joins — essential for maintaining data integrity in CRUD operations.

✅ In contrast:

• An index does not guarantee uniqueness or non-nullability, and you cannot reliably use an indexed column as a foreign key target unless it’s also a primary key or unique constraint.

🔹 Bottom line:
Yes — we need primary keys to guarantee no duplicates, enforce non-nullability, and maintain consistency when using foreign keys for relational integrity.

A composite key means the primary key of a table is made up of two or more columns, and you need to map this combined key in your entity.
In Hibernate (and JPA), you implement composite keys using either:

• @Embeddable + @EmbeddedId → recommended, modern, type-safe approach.
• @IdClass → older, more verbose alternative.

🔹 Approach 1: @Embeddable + @EmbeddedId (recommended)

✅ Step 1: Create a key class annotated with @Embeddable

@Embeddable
public class EnrollmentId implements Serializable {
    private Long studentId;
    private Long courseId;

    // Must have default constructor, getters/setters, equals, and hashCode!
    public EnrollmentId() {}
    // getters, setters, equals, hashCode...
}

✅ Step 2: Use @EmbeddedId in your entity

@Entity
public class Enrollment {
    @EmbeddedId
    private EnrollmentId id;

    @ManyToOne
    @MapsId("studentId") // maps studentId in EnrollmentId
    @JoinColumn(name = "student_id")
    private Student student;

    @ManyToOne
    @MapsId("courseId") // maps courseId in EnrollmentId
    @JoinColumn(name = "course_id")
    private Course course;

    private String grade;

    // getters and setters
}

🔹 What happens:

• The table enrollment has a composite primary key of (student_id, course_id).
• Hibernate maps these two columns together as EnrollmentId.

🔹 Generated SQL table:

CREATE TABLE enrollment (
  student_id BIGINT NOT NULL,
  course_id BIGINT NOT NULL,
  grade VARCHAR(10),
  PRIMARY KEY (student_id, course_id),
  FOREIGN KEY (student_id) REFERENCES student(id),
  FOREIGN KEY (course_id) REFERENCES course(id)
);

🔹 Approach 2: Using @IdClass
✅ Define a simple class with the same fields as the composite key:

public class EnrollmentId implements Serializable {
    private Long studentId;
    private Long courseId;
    // default constructor, equals, hashCode...
}

@Entity
@IdClass(EnrollmentId.class)
public class Enrollment {
    @Id
    private Long studentId;

    @Id
    private Long courseId;

    private String grade;
    // getters and setters
}

🔹 Key difference:

• @IdClass keeps key fields in the entity itself, while @EmbeddedId uses a separate embedded object.

When to use which?
✅ Use @EmbeddedId for cleaner, more object-oriented design → easier to reuse key classes, especially with associations.
✅ Use @IdClass if you want key fields directly in your entity.

✅ Key takeaway:
To implement composite keys in Hibernate:

• Create an @Embeddable class representing the key.
• Use @EmbeddedId in your entity.
• Make sure your key class has proper equals() and hashCode() implementations!

A many-to-many mapping models a relationship where multiple instances of one entity can relate to multiple instances of another entity, and vice versa — like a student can enroll in many courses, and a course can have many students.

In relational databases, many-to-many relationships always require a join table, since neither side can hold a simple foreign key to represent multiple references.

🔹 Real-world examples:

• Students ↔ Courses
• Users ↔ Roles
• Authors ↔ Books

🔹 How to map many-to-many in Hibernate (JPA annotations):
You use @ManyToMany on both entities, optionally with @JoinTable to customize the join table details.

✅ Example: Student ↔ Course

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses = new ArrayList<>();

    // getters and setters
}

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;

    @ManyToMany(mappedBy = "courses")
    private List<Student> students = new ArrayList<>();

    // getters and setters
}

🔹 What happens in the database:
Hibernate automatically creates a join table like:

student_course
------------------------
student_id | course_id

Each row in this join table links one student to one course, enabling the many-to-many association.

🔹 Bidirectional mapping:

• The mappedBy attribute in Course.students points to the courses field in Student.
• This tells Hibernate which side owns the relationship and avoids creating two join tables.

🔹 How to use it in code:

Student student = new Student();
student.setName("Alice");

Course course1 = new Course();
course1.setTitle("Math");

Course course2 = new Course();
course2.setTitle("Physics");

// Link both sides of the relationship
student.getCourses().add(course1);
student.getCourses().add(course2);
course1.getStudents().add(student);
course2.getStudents().add(student);

session.persist(student); // cascades can optionally persist courses

🔹 Key points:
✅ Join table is required for all many-to-many mappings → no direct foreign key can represent it.
✅ Supports both unidirectional (one side knows about the other) and bidirectional (both sides know about each other) mappings.
✅ Can customize the join table name and columns using @JoinTable.

✅ Key takeaway:
Many-to-many mapping in Hibernate models associations where multiple entities on both sides can relate to each other, using a join table mapped with @ManyToMany.

You use @OneToMany without mappedBy when you want to create a unidirectional one-to-many relationship where only the parent knows about the children, and you don’t want or can’t add a foreign key to the child table.

🔹 What happens technically?

• Without mappedBy, Hibernate has no “owning side” telling it which table contains the foreign key.
• So it creates a join table linking the primary keys of both tables to represent the one-to-many association.

🔹 Example:

@Entity
public class Department {
    @OneToMany // no mappedBy!
    @JoinTable(
        name = "department_employee",
        joinColumns = @JoinColumn(name = "department_id"),
        inverseJoinColumns = @JoinColumn(name = "employee_id")
    )
    private List<Employee> employees = new ArrayList<>();
}

🔹 What Hibernate does:
Creates a join table like:

department_employee
---------------------
department_id | employee_id

🔹 Why might you do this?
✅ You can’t or don’t want to modify the child table (e.g., Employee table owned by another team or legacy system).
✅ You need a unidirectional relationship (only parent knows children), and your design doesn’t require the child to know the parent.
✅ You want to model something like a “basket of unrelated items”, where you just link existing rows without adding a foreign key in the item table.

🔹 What’s the downside?
❌ A join table adds complexity and indirection in the database → usually unnecessary if you can add a simple foreign key in the child table.
❌ Slightly less performant than a direct foreign key for one-to-many, especially with large datasets.

🔹 Comparison summary:

✅ Key takeaway:
Use @OneToMany without mappedBy only when you want unidirectional relationships without modifying the child table, knowing that Hibernate will create a join table to maintain the association.

🔹 By default in JPA/Hibernate:

• If you write @OneToMany without mappedBy, Hibernate creates a join table to associate the two entities.
• A join table is a separate table just to link parent IDs and child IDs → unnecessary if you already have a foreign key.

🔹 Example without mappedBy (unidirectional):

@Entity
public class Department {
    @OneToMany // no mappedBy!
    private List<Employee> employees = new ArrayList<>();
}

🔹 What Hibernate does:
Creates an additional table like department_employee with:

department_employee
--------------------
department_id | employee_id

This join table tracks which employees belong to which department, because Hibernate has no idea that the Employee table might have a department_id foreign key.

🔹 Example with mappedBy (bidirectional):

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

@Entity
public class Employee {
    @ManyToOne
    @JoinColumn(name = "department_id") // actual foreign key in Employee table
    private Department department;
}

🔹 What Hibernate does now:
✅ No join table needed!
✅ Hibernate sees the department field in Employee as the owning side, which already maps a foreign key (department_id) directly in employees table:

employees
-------------------------
id | name | department_id

🔹 So what does mappedBy do?
✅ Tells Hibernate which field in the child entity owns the relationship.
✅ Signals: “This one-to-many association should rely on the child’s foreign key column, not a separate join table.”

🔹 Key takeaway:
🟢 With mappedBy → Hibernate uses a foreign key in the child table (no join table).
🔴 Without mappedBy → Hibernate creates a separate join table to store parent-child associations.

✅ Bottom line:
The mappedBy attribute in @OneToMany avoids unnecessary join tables by telling Hibernate to rely on the existing foreign key in the “many” side’s table.

A one-to-many mapping models a relationship where one entity instance is associated with many instances of another entity. This is the typical way to map hierarchical or parent-child relationships in a relational database and your Java entity model.

🔹 Example real-world scenarios:

• A Department has many Employees.
• A BlogPost has many Comments.
• A Customer has many Orders.

🔹 How to map it in Hibernate (JPA annotations):
You use @OneToMany on the parent entity, typically with a List or Set of child entities.

Example: Department → Employee

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Employee> employees = new ArrayList<>();

    // getters and setters
}

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToOne
    @JoinColumn(name = "department_id") // foreign key in employees table
    private Department department;

    // getters and setters
}

🔹 How it looks in the database:

• departments table with id primary key.
• employees table with id primary key and department_id foreign key referencing departments.id.

🔹 Key features of one-to-many mapping:
✅ @OneToMany(mappedBy = "department") tells Hibernate:

• The department field in Employee owns the relationship.
• Don’t create a join table — instead, use the department_id foreign key in employees.

✅ cascade = CascadeType.ALL → saves, updates, or deletes child entities automatically when you perform these operations on the parent.

✅ orphanRemoval = true → automatically deletes child records if they’re removed from the parent’s collection.

🔹 Managing the relationship in code:

Department department = new Department();
department.setName("Engineering");

Employee emp1 = new Employee();
emp1.setName("Alice");
emp1.setDepartment(department);

Employee emp2 = new Employee();
emp2.setName("Bob");
emp2.setDepartment(department);

// Add employees to department
department.getEmployees().add(emp1);
department.getEmployees().add(emp2);

session.persist(department); // cascades to save employees

🔹 Key points:
✅ One-to-many is always bidirectional: @OneToMany on parent ↔ @ManyToOne on child.
✅ In the database, it’s implemented using a foreign key in the “many” side’s table (e.g., employees.department_id).
✅ The mappedBy attribute ensures no join table — just a direct foreign key.

Key takeaway:
One-to-many mapping in Hibernate models a parent-child relationship where one parent entity relates to many child entities, backed by a foreign key, and mapped using @OneToMany / @ManyToOne.

✅ 1) What does a one-to-one relationship look like in the database?

• There’s one table for each entity, e.g.:
  • users table with primary key id.
  • user_profile table with primary key id and a foreign key column pointing back to users.id.

🔹 Schema example (using UserProfile owning the relationship):

CREATE TABLE users (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  username VARCHAR(255) NOT NULL
);

CREATE TABLE user_profile (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  address VARCHAR(255),
  user_id BIGINT UNIQUE,            -- unique foreign key to enforce 1-1
  CONSTRAINT fk_user_profile_user
    FOREIGN KEY (user_id) REFERENCES users(id)
);

✅ The UNIQUE constraint on user_profile.user_id enforces one-to-one: a profile cannot be shared by multiple users.

🔹 How it links:

• Each row in user_profile has a unique user_id pointing to one row in users.

✅ 2) Does calling profile.getUser() generate additional SQL?

Yes, it depends on the fetch type you configure:

🔹 EAGER fetching (default for @OneToOne)

@OneToOne
@JoinColumn(name = "user_id")
private User user;

When you load UserProfile, Hibernate immediately joins or separately fetches the User → so calling profile.getUser() later does not trigger a new SQL, because the User is already loaded.

🔹 LAZY fetching (explicitly set)

@OneToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "user_id")
private User user;

When you load UserProfile, Hibernate does not load the associated User yet.

Calling profile.getUser() for the first time will trigger a separate SQL query like:

select ... from users where id = ?

This is called lazy loading — it defers loading until you actually access the relationship.

🔹 Example SQL behavior with LAZY:

UserProfile profile = session.get(UserProfile.class, 1L); // loads profile only

// No query for user yet

User user = profile.getUser(); // triggers separate SQL here to fetch User

🔹 Hibernate-generated SQL with LAZY fetch:
1️⃣ Initial load:

select ... from user_profile where id = 1;

2️⃣ When accessing profile.getUser():

select ... from users where id = ?;

✅ Key takeaway:

• In the database, a one-to-one relationship is typically implemented with a foreign key + unique constraint to enforce exclusivity.
• Whether profile.getUser() triggers an additional SQL depends entirely on your fetch type:
  • EAGER → loads with the owning entity, no extra SQL later.
  • LAZY → loads only when you access the related entity, generating an additional SQL at that moment.