High-Performance Java Persistence – Part Two

Another milestone has been reached

The second part of High-Performance Java Persistence book is out. It’s been almost a year since I started writing this book, and seven months since I published the first part.

Table of content

Before explaining what the second part is all about, it’s better to take a look at the current table of content:

I Introduction
1. Preface
1.1 The database server and the connectivity layer
1.1.1 The ORM framework
1.1.2 The native query builder framework
2. Performance and Scaling
2.1 Response time and throughput
2.2 Database connections boundaries
2.3 Scaling up and scaling out
2.3.1 Master-Slave replication
2.3.2 Multi-Master replication
2.3.3 Sharding
II JDBC and Database Essentials
3. JDBC Connection Management
3.1 DriverManager
3.2 DataSource
3.2.1 Why is pooling so much faster?
3.3 Queuing theory capacity planning
3.4 Practical database connection provisioning
3.4.1 A real-life connection pool monitoring example
3.4.1.1 Concurrent connection request count metric
3.4.1.2 Concurrent connection count metric
3.4.1.3 Maximum pool size metric
3.4.1.4 Connection acquisition time metric
3.4.1.5 Retry attempts metric
3.4.1.6 Overall connection acquisition time metric
3.4.1.7 Connection lease time metric
4. Batch Updates
4.1 Batching Statements
4.2 Batching PreparedStatements
4.2.1 Choosing the right batch size
4.2.2 Bulk operations
4.3 Retrieving auto-generated keys
4.3.1 Sequences to the rescue
5. Statement Caching
5.1 Statement lifecycle
5.1.1 Parser
5.1.2 Optimizer
5.1.2.1 Execution plan visualization
5.1.3 Executor
5.2 Caching performance gain
5.3 Server-side statement caching
5.3.1 Bind-sensitive execution plans
5.4 Client-side statement caching
6. ResultSet Fetching
6.1 ResultSet scrollability
6.2 ResultSet changeability
6.3 ResultSet holdability
6.4 Fetching size
6.5 ResultSet size
6.5.1 Too many rows
6.5.1.1 SQL limit clause
6.5.1.2 JDBC max rows
6.5.1.3 Less is more
6.5.2 Too many columns
7. Transactions
7.1 Atomicity
7.2 Consistency
7.3 Isolation
7.3.1 Concurrency control
7.3.1.1 Two-phase locking
7.3.1.2 Multi-Version Concurrency Control
7.3.2 Phenomena
7.3.2.1 Dirty write
7.3.2.2 Dirty read
7.3.2.3 Non-repeatable read
7.3.2.4 Phantom read
7.3.2.5 Read skew
7.3.2.6 Write skew
7.3.2.7 Lost update
7.3.3 Isolation levels
7.3.3.1 Read Uncommitted
7.3.3.2 Read Committed
7.3.3.3 Repeatable Read
7.3.3.4 Serializable
7.4 Durability
7.5 Read-only transactions
7.5.1 Read-only transaction routing
7.6 Transaction boundaries
7.6.1 Distributed transactions
7.6.1.1 Two-phase commit
7.6.2 Declarative transactions
7.7 Application-level transactions
7.7.1 Pessimistic and optimistic locking
7.7.1.1 Pessimistic locking
7.7.1.2 Optimistic locking
III JPA and Hibernate
8. Why JPA and Hibernate matter
8.1 The impedance mismatch
8.2 JPA vs. Hibernate
8.3 Schema ownership
8.4 Write-based optimizations
8.5 Read-based optimizations
8.6 Wrap-up
9. Connection Management and Monitoring
9.1 JPA connection management
9.2 Hibernate connection providers
9.2.1 DriverManagerConnectionProvider
9.2.2 C3P0ConnectionProvider
9.2.3 HikariCPConnectionProvider
9.2.4 DatasourceConnectionProvider
9.2.5 Connection release modes
9.3 Monitoring connections
9.3.1 Hibernate statistics
9.3.1.1 Customizing statistics
9.4 Statement logging
9.4.1 Statement formatting
9.4.2 Statement-level comments
9.4.3 Logging parameters
9.4.3.1 DataSource-proxy
9.4.3.2 P6Spy
10. Mapping Types and Identifiers
10.1 Types
10.1.1 Primitive types
10.1.2 String types
10.1.3 Date and Time types
10.1.4 Numeric types
10.1.5 Binary types
10.1.6 UUID types
10.1.7 Other types
10.1.8 Custom types
10.2 Identifiers
10.2.1 UUID identifiers
10.2.1.1 The assigned generator
10.2.2 The legacy UUID generator
10.2.2.1 The newer UUID generator
10.2.3 Numerical identifiers
10.2.3.1 Identity generator
10.2.3.2 Sequence generator
10.2.3.3 Table generator
10.2.3.4 Optimizers
10.2.3.4.1 The hi/lo algorithm
10.2.3.4.2 The default sequence identifier generator
10.2.3.4.3 The default table identifier generator
10.2.3.4.4 The pooled optimizer
10.2.3.4.5 The pooled-lo optimizer
10.2.3.5 Optimizer gain
10.2.3.5.1 Sequence generator performance gain
10.2.3.5.2 Table generator performance gain
10.2.3.6 Identifier generator performance
11. Relationships
11.1 Relationship types
11.2 @ManyToOne
11.3 @OneToMany
11.3.1 Bidirectional @OneToMany
11.3.2 Unidirectional @OneToMany
11.3.3 Ordered unidirectional @OneToMany
11.3.3.1 @ElementCollection
11.3.4 @OneToMany with @JoinColumn
11.3.5 Unidirectional @OneToMany Set
11.4 @OneToOne
11.4.1 Unidirectional @OneToOne
11.4.2 Bidirectional @OneToOne
11.5 @ManyToMany
11.5.1 Unidirectional @ManyToMany
11.5.2 Bidirectional @ManyToMany
11.5.3 The @OneToMany alternative
12. Inheritance
12.1 Single table
12.2 Join table
12.3 Table-per-class
12.4 Mapped superclass
13. Flushing
13.1 Flush modes
13.2 Events and the action queue
13.2.1 Flush operation order
13.3 Dirty Checking
13.3.1 The default dirty checking mechanism
13.3.1.1 Controlling the Persistence Context size
13.3.2 Bytecode enhancement
14. Batching
14.1 Batching insert statements
14.2 Batching update statements
14.3 Batching delete statements
15. Fetching
15.1 DTO projection
15.1.1 DTO projection pagination
15.1.2 Native query DTO projection
15.2 Query fetch size
15.3 Fetching entities
15.3.1 Direct fetching
15.3.1.1 Fetching a Proxy reference
15.3.1.2 Natural identifier fetching
15.3.2 Query fetching
15.3.3 Fetching associations
15.3.3.1 FetchType.EAGER
15.3.3.2 FetchType.LAZY
15.3.3.2.1 The N+1 query problem
15.3.3.2.2 How to catch N+1 query problems during testing
15.3.3.2.3 LazyInitializationException
15.3.3.2.4 The Open Session in View Anti-Pattern
15.3.3.2.5 Temporary Session Lazy Loading Anti-Pattern
15.3.3.3 Associations and pagination
15.4 Query plan cache
16. Caching
16.1 Caching flavors
16.2 Cache synchronization strategies
16.2.1 Cache-aside
16.2.2 Read-through
16.2.3 Write-invalidate
16.2.4 Write-through
16.2.5 Write-behind
16.3 Database caching
16.4 Application-level caching
16.4.1 Entity aggregates
16.4.2 Distributed key-value stores
16.4.3 Cache synchronization patterns
16.4.4 Synchronous updates
16.4.5 Asynchronous updates
16.4.5.1 Change data capture
16.5 Second-level caching
16.5.1 Enabling the second-level cache
16.5.2 Entity cache loading flow
16.5.3 Entity cache entry
16.5.3.1 Entity reference cache store
16.5.4 Collection cache entry
16.5.5 Query cache entry
16.5.6 Cache concurrency strategies
16.5.6.1 READ_ONLY
16.5.6.1.1 Inserting READ_ONLY cache entries
16.5.6.1.2 Updating READ_ONLY cache entries
16.5.6.1.3 Deleting READ_ONLY cache entries
16.5.6.2 NONSTRICT_READ_WRITE
16.5.6.2.1 Inserting NONSTRICT_READ_WRITE cache entries
16.5.6.2.2 Updating NONSTRICT_READ_WRITE cache entries
16.5.6.2.3 Risk of inconsistencies
16.5.6.2.4 Deleting NONSTRICT_READ_WRITE cache entries
16.5.6.3 READ_WRITE
16.5.6.3.1 Inserting READ_WRITE cache entries
16.5.6.3.2 Updating READ_WRITE cache entries
16.5.6.3.3 Deleting READ_WRITE cache entries
16.5.6.3.4 Soft locking concurrency control
16.5.6.4 TRANSACTIONAL
16.5.6.4.1 XA_Strict mode
16.5.6.4.2 XA mode
16.5.6.4.3 Inserting TRANSACTIONAL cache entries
16.5.6.4.4 Updating TRANSACTIONAL cache entries
16.5.6.4.5 Deleting TRANSACTIONAL cache entries
16.5.7 Query cache strategy
16.5.7.1 Table space query invalidation
16.5.7.2 Native SQL statement query invalidation
17. Concurrency Control
17.1 Hibernate optimistic locking
17.1.1 The implicit optimistic locking mechanism
17.1.1.1 Resolving optimistic locking conflicts
17.1.1.2 Splitting entities
17.1.1.3 Versionless optimistic locking
17.1.1.3.1 OptimisticLockType.DIRTY update caveat
17.2 The explicit locking mechanism
17.2.1 PESSIMISTIC_READ and PESSIMISTIC_WRITE
17.2.1.1 Lock scope
17.2.1.2 Lock timeout
17.2.2 LockModeType.OPTIMISTIC
17.2.2.1 Inconsistency risk
17.2.3 LockModeType.OPTIMISTIC_FORCE_INCREMENT
17.2.4 LockModeType.PESSIMISTIC_FORCE_INCREMENT

I initially estimated that the whole book would be around 250-300 pages. I was wrong. Even without the third part, the book is over 400 pages, and it covers database essentials, JDBC drivers peculiarities, as well as many topics about JPA and Hibernate.

The first part of the book is explained in this post.

The second part has been covered by the following articles:

The 17th chapter has just been released, and it goes through all sorts of concurrency control idioms. One of the greatest advantages of using JPA and Hibernate is that it provides advanced concurrency control mechanisms. I don’t talk only about the typical numerical version optimistic locking, but also about the versionless application-level concurrency control strategy and the subentity splitting pattern.

This chapter covers pessimistic locking as well, going beyond the classic PESSIMISTIC_READ and PESSIMISTIC_WRITE which you might already be familiar with. I describe how the follow-on locking mechanism works when the database engine cannot apply the FOR UPDATE clause properly. You can also find a detailed explanation of the SKIP LOCKED clause, which, like many other features, it’s a Hibernate-specific feature.

More to come

Even with so many topics, the book is still in progress because the third part is going to cover jOOQ, so stay tuned!

Enter your email address to follow this blog and receive notifications of new posts by email.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s