Since the book is a comprehensive technical manual (often 400+ pages), "PDF 20" is likely a reference to a page range or, more commonly, Chapter 20. In the standard table of contents for this book, Chapter 20 covers Database Partitioning (specifically focusing on PostgreSQL implementation as a case study).
Below is a comprehensive content summary and key takeaways from Chapter 20: Database Partitioning. high-performance java persistence pdf 20
Use @Fetch(FetchMode.JOIN) or @Fetch(FetchMode.SUBSELECT) for efficient loading strategies. Since the book is a comprehensive technical manual
Since Hibernate 6 and newer JDBC drivers are partition-aware, the chapter discusses how to ensure the database performs Partition Pruning. Eager Loading (FetchType
SELECT * FROM posts WHERE created_on = '2023-05-01', PostgreSQL knows to look only in posts_2023.SELECT * FROM posts WHERE title = 'Java'), the database must scan every single partition. This is often slower than scanning a single large table due to the overhead of merging results from multiple partitions.Perhaps the most practical "page 20" wisdom concerns the JDBC fetch size. The default fetch size for most drivers is 10. This means that to read a result set of 10,000 rows, the JDBC driver makes 1,000 round-trips to the database. In a high-latency network environment (e.g., microservices communicating across regions), this is a death sentence.
High-performance persistence mandates a larger fetch size—often 1,000 or 10,000, depending on the JVM heap memory. By setting statement.setFetchSize(1000), the driver retrieves rows in chunks. This shifts the performance profile from round-trip bound to bandwidth bound, which is substantially easier to optimize.
If you need the digital document (PDF) legally and instantly:
vladmihalcea/high-performance-java-persistence. Clone it for 20+ working examples.vladmihalcea.com/books. Download the free sample (the first 20 pages/PDF). This is likely the exact "pdf 20" users seek.