Hibernatejoinfetch
- 1. Hibernate Fetch Strategies, N+1 Select Problem 1
- 2. Topics ● Fetching strategies ● Types of fetching strategies – How fetching is done – When fetching is done ● N+1 select problem – Factors that influence number of select statements – Various examples ● Recommendation 2
- 3. Fetching Strategies 3
- 4. What is a Fetching Strategy? ● A fetching strategy is the strategy Hibernate will use for retrieving associated objects if the application needs to navigate the association. ● Fetching strategy will have performance impact ● Fetch strategies may be declared in the mapping files, or over-ridden by a particular HQL or Criteria query. 4
- 5. Types of Fetching Strategies ● How fetching is done – Join – Select (default) – Subselect – Batch ● When fetching is done – immediate – lazy (default) 5
- 6. Fetching Strategies: How Fetching is Done 6
- 7. Join Fetching ● Hibernate retrieves the associated instance or collection in the same SELECT, using an OUTER JOIN 7
- 8. Join Fetching in HQL String hql = "from Product p join fetch p.supplier as s"; Query query = session.createQuery(hql); List results = query.list(); 8
- 9. Join Fetching in Criteria API Criteria crit = session.createCriteria(Product.class); crit.setFetchMode("supplier", FetchMode.JOIN); List results = crit.list(); 9
- 10. Select Fetching ● Default fetch mode ● Vulnerable to N+1 selects problem – “N” number of SELECT's are used to retrieve the associated entity or collection. ● Unless you explicitly disable lazy fetching by specifying lazy="false", the subsequent select will only be executed when you actually access the association. 10
- 11. Subselect Fetching ● A second SELECT is used to retrieve the associated collections for all entities retrieved in a previous query or fetch. ● Unless you explicitly disable lazy fetching by specifying lazy="false", this second select will only be executed when you actually access the association. 11
- 12. Batch Fetching ● An optimization strategy for select fetching - Hibernate retrieves a batch of entity instances or collections in a single SELECT, by specifying a list of primary keys or foreign keys. 12
- 13. Tuning fetch strategies ● Select fetching (the default) is extremely vulnerable to N+1 selects problems, so you might want to enable join fetching in the mapping document: <set name="permissions" fetch="join"> <key column="userId"/> <one-to-many class="Permission"/> </set 13
- 14. Fetching Strategies: When Fetching is Done 14
- 15. Lazy Fetching ● A collection is fetched when the application invokes an operation upon that collection ● Default for collections 15
- 16. N+1 Select Problem 16
- 17. Example Scenario ● Supplier with a one-to-many relationship with Product. – One Supplier has (supplies) many Products 17
- 18. Example Data ******** Table: Supplier ******* +-------------+----------------------+ | ID | NAME | +-------------+----------------------+ |1 | Supplier Name 1 | |2 | Supplier Name 2 | |3 | Supplier Name 3 | |4 | Supplier Name 4 | +-------------+----------------------+ ******** Table: Product ******* +-------------+----------------------+--------------------------------+------------------------+--------------------+ | ID | NAME | DESCRIPTION | PRICE | SUPPLIERID | +-------------+----------------------+--------------------------------+------------------------+--------------------+ |1 | Product 1 | Name for Product 1 | 2.0 |1 | |2 | Product 2 | Name for Product 2 | 22.0 |1 | |3 | Product 3 | Name for Product 3 | 30.0 |2 | |4 | Product 4 | Name for Product 4 | 7.0 |3 | +-------------+----------------------+--------------------------------+------------------------+--------------------+ 18
- 19. Factors that influence “number of select statements” ● When fetching is done – lazy mode for Supplier ● How fetching is done – Fetch mode used for querying on Product – Select vs. Join ● Whether Supplier is accessed through Product or not ● Caching – Whether Supplier is cached or now 19
- 23. Example #1 ● Factors – lazy mode for Supplier set to “true” (default) – Fetch mode used for querying on Product is Select fetch mode (default) – Supplier information is not accessed – Caching does not play a role for the first time the Supplier is accessed ● Sample project in the hands-on lab – 01HibernateHQLQuery-LazyTrue-SelectFetch- SupplierNotAccessed 23
- 24. Supplier.hbm.xml: lazy=”true” <hibernate-mapping> <!-- lazy attribute is not set so it takes the default value of true --> <class name="Supplier"> <id name="id" type="int"> <generator class="increment"/> </id> <property name="name" type="string"/> <bag name="products" inverse="true" cascade="all,delete- orphan"> <key column="supplierId"/> <one-to-many class="Product"/> </bag> </class> </hibernate-mapping> 24
- 25. Fetch mode is Select Fetch (default) // It takes Select fetch mode as a default Query query = session.createQuery( "from Product p"); List list = query.list(); // Supplier is not being accessed displayProductsListWithoutSupplierName(results); 25
- 26. Supplier is not accessed public static void displayProductsListWithoutSupplierName(List list){ Iterator iter = list.iterator(); if (!iter.hasNext()){ System.out.println("No products to display."); return; } while (iter.hasNext()){ Product product = (Product) iter.next(); // String msg = product.getSupplier().getName() + "t"; String msg = "t"; msg += product.getName() + "t"; msg += product.getPrice() + "t"; msg += product.getDescription(); System.out.println(msg); } } 26
- 27. Number of Select Statements select ... various field names ... from PRODUCT ● 1 select statement for Product ● Delayed N+1 select problem, however, since Supplier is not accessed for now 27
- 28. Example #2 LazyTrue-SelectFetch- SupplierAccessed 28
- 29. Example #2 ● Factors – lazy mode for Supplier set to “true” (default) – Fetch mode used for querying on Product is Select fetch mode (default) – Supplier information is accessed – Caching does not play a role for the first time the Supplier is accessed ● Sample project in the hands-on lab – 02HibernateHQLQuery-LazyTrue-SelectFetch- SupplierAccessed 29
- 30. Fetch mode is Select Fetch (default) // It takes Select fetch mode as a default Query query = session.createQuery( "from Product p"); List list = query.list(); // Supplier is being accessed displayProductsListWithSupplierName(results); 30
- 31. Supplier is accessed public static void displayProductsListWithSupplierName(List list){ Iterator iter = list.iterator(); if (!iter.hasNext()){ System.out.println("No products to display."); return; } while (iter.hasNext()){ Product product = (Product) iter.next(); String msg = product.getSupplier().getName() + "t"; String msg = "t"; msg += product.getName() + "t"; msg += product.getPrice() + "t"; msg += product.getDescription(); System.out.println(msg); } } 31
- 32. Select Statements Used select ... various field names ... from PRODUCT select ... various field names ... from SUPPLIER where SUPPLIER.id=? select ... various field names ... from SUPPLIER where SUPPLIER.id=? select ... various field names ... from SUPPLIER where SUPPLIER.id=? ● Result – 1 select statement for Product – N select statements for Supplier ● This is N+1 select problem! 32
- 33. Example #3 LazyFalse-SelectFetch- SupplierAccessed 33
- 34. Example Scenario #3 ● Factors – lazy mode for Supplier set to “false” – Fetch mode used for querying on Product is Select fetch mode (default) – Supplier information is not accessed – Caching does not play a role for the first time the Supplier is accessed ● Sample project in the hands-on lab – 03HibernateHQLQuery-LazyFase-SelectFetch- SupplierNotAccessed 34
- 35. Supplier.hbm.xml: lazy=”false” <hibernate-mapping> <class name="Supplier" lazy="false"> <id name="id" type="int"> <generator class="increment"/> </id> <property name="name" type="string"/> <bag name="products" inverse="true" cascade="all,delete- orphan"> <key column="supplierId"/> <one-to-many class="Product"/> </bag> </class> </hibernate-mapping> 35
- 36. Fetch mode is Select Fetch (default) // It takes Select fetch mode as a default Query query = session.createQuery( "from Product p"); List list = query.list(); // Supplier is not being accessed displayProductsListWithoutSupplierName(results); 36
- 37. Select Statements Used select ... various field names ... from PRODUCT select ... various field names ... from SUPPLIER where SUPPLIER.id=? select ... various field names ... from SUPPLIER where SUPPLIER.id=? select ... various field names ... from SUPPLIER where SUPPLIER.id=? ● Result – 1 select statement for Product – N select statements for Supplier ● This is N+1 select problem! – Even though Supplier is not accessed, because lazy is set to false, N select statements are used to access Supplier 37
- 39. Example Scenario #4 ● Factors – lazy mode for Supplier set to “false” – Fetch mode used for querying on Product is Select fetch mode (default) – Supplier information is accessed – Caching does not play a role for the first time the Supplier is accessed ● Sample project in the hands-on lab – 04HibernateHQLQuery-LazyFase-SelectFetch- SupplierAccessed 39
- 40. Select Statements Used select ... various field names ... from PRODUCT select ... various field names ... from SUPPLIER where SUPPLIER.id=? select ... various field names ... from SUPPLIER where SUPPLIER.id=? select ... various field names ... from SUPPLIER where SUPPLIER.id=? ● Result – 1 select statement for Product – N select statements for Supplier ● This is N+1 select problem! – Even though Supplier is not accessed, because lazy is set to false, N select statements are used to access Supplier 40
- 42. Example #5 ● Factors – lazy mode for Supplier set to “true” (default) – Fetch mode used for querying on Product is Join fetch mode – Supplier information is not accessed – Caching does not play a role for the first time the Supplier is accessed ● Sample project in the hands-on lab – 05HibernateHQLQuery-LazyTrue-JoinFetch- SupplierNotAccessed 42
- 43. Fetch mode is Join Fetch // Perform Join Fetch String hql = "from Product p join fetch p.supplier as s"; Query query = session.createQuery(hql); List results = query.list(); // Supplier is not being accessed displayProductsListWithoutSupplierName(results); 43
- 44. Number of Select Statements select ... various field names from Product product0_ inner join Supplier supplier1_ on product0_.supplierId=supplier1_.id ● 1 inner join select statement ● No N+1 select problem 44
- 46. Example #6 ● Factors – lazy mode for Supplier set to “true” (default) – Fetch mode used for querying on Product is Join fetch mode – Supplier information is accessed – Caching does not play a role for the first time the Supplier is accessed ● Sample project in the hands-on lab – 06HibernateHQLQuery-LazyTrue-JoinFetch- SupplierAccessed 46
- 47. Fetch mode is Join Fetch // Perform Join Fetch String hql = "from Product p join fetch p.supplier as s"; Query query = session.createQuery(hql); List results = query.list(); // Supplier is being accessed displayProductsListWithSupplierName(results); 47
- 48. Number of Select Statements select ... various field names from Product product0_ inner join Supplier supplier1_ on product0_.supplierId=supplier1_.id ● 1 inner join select statement ● No N+1 select problem 48
- 50. Example #7 ● Factors – lazy mode for Supplier set to “false” – Fetch mode used for querying on Product is Join fetch mode – Supplier information is not accessed – Caching does not play a role for the first time the Supplier is accessed ● Sample project in the hands-on lab – 07HibernateHQLQuery-LazyFalse-JoinFetch- SupplierNotAccessed 50
- 51. Number of Select Statements select ... various field names from Product product0_ inner join Supplier supplier1_ on product0_.supplierId=supplier1_.id ● 1 inner join select statement ● No N+1 select problem 51
- 53. Example #8 ● Factors – lazy mode for Supplier set to “false” – Fetch mode used for querying on Product is Join fetch mode – Supplier information is accessed – Caching does not play a role for the first time the Supplier is accessed ● Sample project in the hands-on lab – 08HibernateHQLQuery-LazyFalse-JoinFetch- SupplierAccessed 53
- 54. Number of Select Statements select ... various field names from Product product0_ inner join Supplier supplier1_ on product0_.supplierId=supplier1_.id ● 1 inner join select statement ● No N+1 select problem 54
- 55. Example #9 LazyTrue-SelectFetch- SupplierAccessed-Caching 55
- 56. Example #2 ● Factors – lazy mode for Supplier set to “true” (default) – Fetch mode used for querying on Product is Select fetch mode (default) – Supplier information is accessed – Caching play a role the Supplier is accessed the second time ● Sample project in the hands-on lab – HibernateHQLQuery-LazyTrue-SelectFetch- SupplierAccessed-Caching 56
- 57. Access Supplier Through Cache System.out.println("n---Performing HQL query with LazyTrue-SelectFetch-SupplierAccessed..." Query query = session.createQuery("from Product"); List results = query.list(); displayProductsListWithSupplierName(results); System.out.println("n---Performing HQL query using Cache..."); Query query = session.createQuery("from Product"); List results = query.list(); displayProductsListWithSupplierName(results); // Clear cache session.clear(); System.out.println("n---Performing HQL query after clearing Cache..."); Query query = session.createQuery("from Product"); List results = query.list(); displayProductsListWithSupplierName(results); 57
- 58. Select Statements Used select ... various field names ... from PRODUCT select ... various field names ... from SUPPLIER where SUPPLIER.id=? select ... various field names ... from SUPPLIER where SUPPLIER.id=? select ... various field names ... from SUPPLIER where SUPPLIER.id=? select ... various field names ... from PRODUCT select ... various field names ... from PRODUCT select ... various field names ... from SUPPLIER where SUPPLIER.id=? select ... various field names ... from SUPPLIER where SUPPLIER.id=? select ... various field names ... from SUPPLIER where SUPPLIER.id=? 58
- 60. Recommendation ● Join fetching is good for small collection of child objects often used with parent ● Large collections and/or not always used collections are better retrieved with lazy select fetching 60
- 61. Hibernate Fetch Strategies, N+1 Select Problem 61