Key Concepts Summarized

1. Entity Relationship Overview:

   • Restaurant (1) <--> (*) FoodItem:

     • Restaurant: Parent, non-owning (inverse) side.
     • FoodItem: Child, owning side (contains foreign key restaurant_id).
     • Annotations:
       • Restaurant: @OneToMany(mappedBy = "myRestaurant", cascade = CascadeType.ALL)
       • FoodItem: @ManyToOne @JoinColumn(name = "restaurant_id")
     • mappedBy: Specifies the owning side's property (myRestaurant in FoodItem) to avoid an unnecessary join table (restaurants_food_items).

   • Cascading: Propagates operations (e.g., persist, remove) from Restaurant to FoodItem using cascade = CascadeType.ALL.

   • Unique Constraint: Ensures uniqueness of item_name and restaurant_id combination in the food_items table.

     @Table(name = "food_items", uniqueConstraints =
         @UniqueConstraint(columnNames = {"item_name", "restaurant_id"}))
     
     

2. Helper Methods:

   • Add helper methods in Restaurant (parent) to manage bidirectional relationships:

     public void addFoodItem(FoodItem foodItem) {
         foodItems.add(foodItem);
         foodItem.setMyRestaurant(this);
     }
     
     public void removeFoodItem(FoodItem foodItem) {
         foodItems.remove(foodItem);
         foodItem.setMyRestaurant(null);
     }
     
     

3. Cascading Issue:

   • Without session.persist(foodItem), Hibernate won't insert records into food_items unless explicitly persisted.
   • Solution: Use cascade = CascadeType.ALL on @OneToMany to propagate operations from Restaurant to FoodItem.

4. Deletion:

   • To delete a Restaurant, first delete associated FoodItem records (child) to avoid foreign key constraint violations.
   • Cascading (CascadeType.ALL) automates this.

5. LazyInitializationException:

   • Cause: Default fetch type for @OneToMany is LAZY, meaning foodItems is a proxy and not fetched until accessed within a session.
   • When it occurs: Accessing unfetched data (proxy) outside the session scope (after tx.commit).
   • Solutions:

     1. Eager Fetching:

        @OneToMany(mappedBy = "myRestaurant", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
        private List<FoodItem> foodItems = new ArrayList<>();
        
        

        • Suitable for small collections but fetches all data, potentially impacting performance.

     2. Access within Session:

        • Access foodItems.size() within the session to force fetching.
        • Disadvantage: May lead to "N+1 query problem" (multiple queries).

     3. JPQL with JOIN FETCH:

        select r from Restaurant r left join fetch r.foodItems where r.name = :nm
        
        

        • Fetches Restaurant and FoodItem in a single query, avoiding N+1 issue.

6. Unidirectional Many-to-One (Category *<-- Product):

   • Product:

     @ManyToOne
     @JoinColumn(name = "category_id", nullable = false)
     private Category productCategory;
     
     

   • Category: No reference to Product (no List<Product>), making it unidirectional.

   • Query Example (Display products by category name):

     select p from Product p where p.productCategory.name = :nm
     
     

7. Bidirectional One-to-Many (Category 1 <--> * Product):

   • Category:

     @OneToMany(mappedBy = "productCategory", cascade = CascadeType.ALL)
     private List<Product> products = new ArrayList<>();
     
     

   • Product:

     @ManyToOne
     @JoinColumn(name = "category_id", nullable = false)
     private Category productCategory;
     
     

   • Query Example (Display products by category name):

     select p from Product p where p.productCategory.name = :nm
     
     

     • Same as unidirectional, as the query relies on the productCategory reference in Product.

8. Delete Product from Category (Bidirectional):

   • Input: categoryId, productId

   • Steps:

     Session session = sessionFactory.getCurrentSession();
     Category category = session.get(Category.class, categoryId);
     Product product = session.get(Product.class, productId);
     if (category != null && product != null && product.getProductCategory().getId().equals(categoryId)) {
         category.removeProduct(product); // Removes product from category's list and sets FK to null
         session.commit();
     } else {
         throw new IllegalStateException("Invalid category or product, or product not in category");
     }
     
     

   • Issue: Foreign key may be set to null, causing an exception if nullable = false on @JoinColumn.

   • Solution: Enable orphanRemoval = true on @OneToMany:

     @OneToMany(mappedBy = "productCategory", cascade = CascadeType.ALL, orphanRemoval = true)
     private List<Product> products = new ArrayList<>();
     
     

     • Removes orphaned Product records when removed from the relationship.

9. Unidirectional One-to-One (User 1 --> 1 Address):

   • User:

     @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
     @JoinColumn(name = "address_id")
     private Address myAddress;
     
     

   • Address: No reference to User.

   • Fetch type defaults to EAGER but can be set to LAZY.

10. Unidirectional Many-to-Many (Restaurant *<--> Tag):

    • Tag:

      @ManyToMany
      @JoinTable(name = "my_restaurant_tags")
      private Set<Restaurant> restaurants = new HashSet<>();
      
      

    • Restaurant: No reference to Tag.

    • Recommendation: Use Set to reduce duplicate queries.

11. Many-to-Many with Additional Columns:

    • Example: Order *<--> FoodItem with additional columns (e.g., quantity).
    • Solution: Split into two @ManyToOne relationships with an intermediate entity (OrderLine):

      • OrderLine:

        @ManyToOne
        @JoinColumn(name = "order_id")
        private Order order;
        
        @ManyToOne
        @JoinColumn(name = "food_item_id")
        private FoodItem foodItem;
        
        private int quantity; // Additional column
        
        

12. Value Types:

    • Embeddable (AdhaarCard):

      @Embeddable
      public class AdhaarCard {
          private String number;
          // Other fields
      }
      
      @Entity
      public class User {
          @Embedded
          private AdhaarCard adhaarCard;
      }
      
      

    • Collection of Basic Types (Hobbies):

      @ElementCollection
      @CollectionTable(name = "user_hobbies", joinColumns = @JoinColumn(name = "user_id"))
      @Column(name = "hobby_name")
      private List<String> hobbies = new ArrayList<>();
      
      

Solutions to Use Cases

1. Add New Restaurant

• Input: name, address, description, city

• Output: Success message

• Implementation:

  public String addRestaurant(String name, String address, String description, String city) {
      Session session = sessionFactory.getCurrentSession();
      Restaurant restaurant = new Restaurant();
      restaurant.setName(name);
      restaurant.setAddress(address);
      restaurant.setDescription(description);
      restaurant.setCity(city);
      session.persist(restaurant);
      session.getTransaction().commit();
      return "Restaurant added successfully with ID: " + restaurant.getId();
  }
  
  

2. Add New Food Item to Restaurant