High-Performance Java Persistence

Table of Contents 5 I Introduction 11 Preface 12 The database server and the connectivity layer 13 The application data access layer 13 The ORM framework 13 The native query builder framework 14 Performance and Scaling 15 Response time and throughput 15 Database connections boundaries 17 Scaling up and scaling out 18 Master-Slave replication 19 Multi-Master replication 20 Sharding 21 II JDBC and Database Essentials 24 JDBC Connection Management 25 DriverManager 26 DataSource 27 Why is pooling so much faster? 31 Queuing theory capacity planning 33 Practical database connection provisioning 36 A real-life connection pool monitoring example 37 Concurrent connection request count metric 38 Concurrent connection count metric 39 Maximum pool size metric 40 Connection acquisition time metric 40 Retry attempts metric 41 Overall connection acquisition time metric 41 Connection lease time metric 42 Batch Updates 43 Batching Statements 43 Batching PreparedStatements 45 Choosing the right batch size 48 Bulk operations 49 Retrieving auto-generated keys 49 Sequences to the rescue 53 Statement Caching 55 Statement lifecycle 55 Parser 56 Optimizer 56 Execution plan visualization 57 Executor 58 Caching performance gain 59 Server-side statement caching 60 Bind-sensitive execution plans 62 Client-side statement caching 66 ResultSet Fetching 70 ResultSet scrollability 71 ResultSet changeability 73 ResultSet holdability 74 Fetching size 74 ResultSet size 77 Too many rows 77 SQL limit clause 78 JDBC max rows 79 Less is more 81 Too many columns 82 Transactions 83 Atomicity 84 Consistency 86 Isolation 87 Concurrency control 88 Two-phase locking 88 Multi-Version Concurrency Control 91 Phenomena 94 Dirty write 96 Dirty read 97 Non-repeatable read 98 Phantom read 99 Read skew 100 Write skew 101 Lost update 102 Isolation levels 103 Read Uncommitted 104 Read Committed 105 Repeatable Read 107 Serializable 108 Durability 109 Read-only transactions 112 Read-only transaction routing 113 Transaction boundaries 115 Distributed transactions 119 Two-phase commit 119 Declarative transactions 120 Application-level transactions 123 Pessimistic and optimistic locking 124 Pessimistic locking 124 Optimistic locking 125 III JPA and Hibernate 127 Why JPA and Hibernate matter 128 The impedance mismatch 129 JPA vs Hibernate 130 Schema ownership 132 Write-based optimizations 134 Read-based optimizations 139 Wrap-up 142 Connection Management and Monitoring 143 JPA connection management 143 Hibernate connection providers 144 DriverManagerConnectionProvider 145 C3P0ConnectionProvider 145 HikariConnectionProvider 146 DatasourceConnectionProvider 146 Connection release modes 147 Monitoring connections 149 Hibernate statistics 151 Customizing statistics 153 Statement logging 156 Statement formatting 157 Statement-level comments 158 Logging parameters 159 DataSource-proxy 159 P6Spy 160 Mapping Types and Identifiers 162 Types 164 Primitive types 164 String types 164 Date and Time types 165 Numeric types 165 Binary types 166 UUID types 166 Other types 167 Custom types 167 Identifiers 173 UUID identifiers 174 The assigned generator 176 The legacy UUID generator 177 The newer UUID generator 177 Numerical identifiers 178 Identity generator 178 Sequence generator 180 Table generator 181 Optimizers 183 The hi/lo algorithm 184 The default sequence identifier generator 186 The default table identifier generator 187 The pooled optimizer 187 The pooled-lo optimizer 190 Optimizer gain 191 Sequence generator performance gain 191 Table generator performance gain 192 Identifier generator performance 192 Relationships 195 Relationship types 196 @ManyToOne 197 @OneToMany 199 Bidirectional @OneToMany 200 Unidirectional @OneToMany 203 Ordered unidirectional @OneToMany 205 @ElementCollection 207 @OneToMany with @JoinColumn 209 @OneToOne 211 Unidirectional @OneToOne 211 Bidirectional @OneToOne 214 @ManyToMany 216 Unidirectional @ManyToMany 216 Bidirectional @ManyToMany 218 The @OneToMany alternative 220 Inheritance 225 Single table 229 Join table 233 Table-per-class 237 Mapped superclass 241 Get the most out of your persistence layer A high-performance data access layer must resonate with the underlying database system. Knowing the inner workings of a relational database and the data access frameworks in use can make the difference between a high-performance enterprise application and one that barely crawls. This book is a journey into Java data access performance tuning. From connection management, to batch updates, fetch sizes and concurrency control mechanisms, it unravels the inner workings of the most common Java data access frameworks. The first part aims to reduce the gap between application developers and database administrators. For this reason, it covers both JDBC and the database fundamentals that are of paramount importance when reducing transaction response times. In this first part, youll learn about connection management, batch updates, statement caching, result set fetching and database transactions. The second part demonstrates how you can take advantage of JPA and Hibernate without compromising application performance. In this second part, youll learn about the most efficient Hibernate mappings (basic types, associations, inheritance), fetching best practices, caching and concurrency control mechanisms. The third part is dedicated to jOOQ and its powerful type-safe querying capabilities, like window functions, common table expressions, upsert, stored procedures and database functions.