Oracle JDBC: High Performance Applications With Oracle 10g (Oaktable Press) [Englisch] [Taschenbuch]

This book is about Oracle JDBC programming, not generic database neutral JDBC programming but Oracle specific. There are many JDBC books available and many Oracle and Oracle programming books but this concentrates narrowly on JDBC for Oracle, and how to get the best performance out of that combination. It is aimed at an audience that already knows Java and probably already knows a little JDBC. It is written in a dry but very readable style and plenty of code examples. At just over 700 pages it is a fairly fat book, but I felt everything was justified and there was nothing that felt like "padding". The code examples are fairly short and tend to be complete programs with a main method rather than snippets that need to be incorporated into a runnable program. Each code example includes a comment about which version of Oracle it will run with, and mostly this covers at least 10.1 and 9.2.

The main emphasis is on compatibility with Oracle 10.g. There is an emphasis on performance which is clear from the title of Chapter 1 "Performance Toolkit" and graphs are used to illustrate the influence of various parameters on performance. The book makes use of UML style class charts, tables and plenty of performance/time line graphs. I particularly liked the use of a flow chart to illustrate the statement processing algorithm. Flow charts seem to be old fashioned, but they are almost perfect for illustrating this type of information. If you were being overly critical of the diagrams, you might describe them as unsophisticated. Thus in Chapter 15 the "Our example application" illustration looks like it was taken from the clip art of a DOS program from around 1987. But if you want pretty pictures you can buy any glossy "Illustrated Walking and Chewing Gum" book that takes your fancy. This book by contrast, concentrates on explaining essential technical and performance information, in the simplest clearest way possible, and they achieve it.

The coverage tends to keep to how Oracle is used in most common "real world" situations, thus the index does not even contain a reference to Grid computing and there is no coverage of distributed transactions, which are described in the introduction as a "less commonly used JDBC feature".

Although chapter 3 is entitled "Introduction to JDBC" it is a lightening tour with code examples that assume they are accessing an Oracle database. There is an emphasis on performance with chapters on statement caching and connection pooling. It not only covers the Oracle specific classes, but also covers where they do not work exactly as per the specification. For example

in chapter 4 "Transactions" there is a note

"In 10g Release 1 and 9i Release 2, the method setReadOnly() of the Connection interface internally does a set transaction read only. This is a bug, as it isn't the intended behavior of the method setReadOnly().."

There are many examples of notes such as this which could be vital when you are struggling with some unexpected quirk of behavior.

With this book you are not getting a re-writing of the documentation, but a description from someone who has actually used the classes. Although the heart of the book is JDBC it does have some excellent coverage of general Java/Oracle programming and configuration issues.

I was particularly interested in the sections on Connection Pooling/Caching and security related issues. These chapters would be of value for anyone writing JDBC for any target database, as it explains some of the implication of connection pooling in terms of authentication. Chapter 15, "Security-related issues" covers the issue of Mapping an end user to a database user. This covers the performance issues of a one to one mapping and the benefit of proxy authentication to get around this.

Performance Performance

Chapter 2 is called "Oracle Fundamentals", thought it might have been called "Oracle performance fundamentals". It covers issues such as the impact of Oracle record locking and the value of using bind variables for inserting records. This includes a performance graph typical of the book. Without bind variables, the graph curve is like an ascent of Mount Everest. By contrast where bind variables are used the increase in time taken represents a very gentle slope. This is the type of advice that could make the difference between your code being optimal or being unusable. In chapter 2 the author gives his mantra for the book as

"we should not just produce code that works; we should produce code that works well".

I interpret that as code that "runs fast" and code you can prove runs fast.

One of the few parts of the book that is probably not essential is chapter 8 which covers Oracle Objects. This can be summed up unfairly as "Oracle supports objects but you probably don't want to use them". However as most Java programmers tend to have an interest in Object Oriented concepts they will probably get some value out of it, even if they decide not to use JDBC to access Oracle Objects.

What about PL/SQL?

The author is not a Java Zelot and puts convincing arguments for when PL/SQL may be a better choice than Java/JDBC. He makes the expected performance argument, but more interesting is the argument that sometimes using PL/SQL may be more portable, in that you should use the procedural language of your target database, e.g. TSQL in SQL server, PLSQL etc. I think this is stretching the argument, and database portability can be more important for some categories of application.

Summary

This is not a book for students who want to learn JDBC from scratch. It is for people who want to write high performance JDBC for accessing Oracle. It takes the view that to build the best application you need to understand the underlying database as well as JDBC. If you are writing Oracle JDBC you need this book. If you are writing platform neutral JDBC you could still benefit from this book as it would allow you to avoid performance bottlenecks specific to Oracle.

"Expert Oracle JDBC Programming" is part of a new series called OakTable Press. This series is written by Oracle experts, making the quality very high. In fact, one of the technical reviewers of this book is "Ask Tom."

This strong relationship with Oracle results in trying to convince the reader to use stored procs/Oracle specific code. This isn't a good or a bad thing - just something to know up front. The author clearly shows what is Oracle specific and describes the tradeoffs.

The book has three sections, starting with an introduction to JDBC. While JDBC knowledge is not required, it is helpful to get full benefit from the book as advanced concepts are introduced very quickly. The book relies heavily on code with all examples clearly explained. The second section goes into Oracle specific concepts. The last section explains best practices, issues and specific performance related concepts.

This book is distinguished from others by the emphasis on good quality, high performing code. Benchmarks are provided from the beginning. Chapter 1 even covers how to time your code.

As you can tell from the title, the book is Oracle specific. So you can copy/paste the code and run it on Oracle. All code examples specifically state whether they work on 9i, 10g or both. The focus of Oracle also allows the author to demonstrate exactly what needs to be done to run/test the examples on Oracle. I recommend this book for Java developers on Oracle.

The previous reviewers are absolutely right about this book. This book is definitely the best book if you are looking to exploit JDBC in combination with Oracle. Note that it covers JDBC on its own right but then suppliments it with info on Oracle. It is way better than any other JDBC book in the market (I have read through most others.) What I liked about this book is:

1. The author gives complete examples for you to work with. He also explains these examples step by step.

2. The author always provides proof for any statement of performance claims he makes in terms of code that anyone can run. This is a refreshingly different approach than some authors who simply state the claims (that are more often than not incorrect)

3. Author's approach is practical and can be used in real life projects.

4. The author goes in-depth into all topics he covers and is not afraid to delve into the details of Oracle architecture when required.

5. There is no "fluff" or "padding". There are no reams of pages just giving API information that is readily available on the web. Instead the author suppliments the JDBC API info and the Oracle documentation on JDBC freely available on the web.

In short, this book bridges the gap between J2EE developers and database developers (focusing on Oracle, of course.)

The only thing to note is that as a reader, you could get bogged down by the first two chapters since they give overview of Oracle architecture and performance tools the author uses. But as you would read the remaining chapters, you would appreciate the contents of these first two chapters.

If you are using JDBC on Oracle, then buy this book! You won't regret it!