- Series: Oaktable Press
- Paperback: 708 pages
- Publisher: Apress; 1st ed. edition (June 2, 2005)
- Language: English
- ISBN-10: 159059407X
- ISBN-13: 978-1590594070
- Product Dimensions: 7.5 x 1.7 x 9.2 inches
- Shipping Weight: 3.4 pounds (View shipping rates and policies)
- Average Customer Review: 8 customer reviews
- Amazon Best Sellers Rank: #2,420,458 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Other Sellers on Amazon
+ $3.75 shipping
+ Free Shipping
Expert Oracle JDBC Programming Paperback – June 2, 2005
See the Best Books of 2018 So Far
Looking for something great to read? Browse our editors' picks for the best books of the year so far in fiction, nonfiction, mysteries, children's books, and much more.
Customers who viewed this item also viewed
Customers who bought this item also bought
About the Author
R.M. Menon has worked with Oracle database for over 11 years, eight of which have been at Oracle Corporation. Menon works as a project lead in the core technology division of Oracle. For the past five years, Menon has used JDBC and other J2EE technologies extensively as part of his work. He believes in the philosophy of proving all assertions, and has strived to follow this philosophy rigorously in his book. When he is not doing research on Oracle, Menon learns Indian classical vocal music and performs at local cultural events as a singer. Occasionally, he also dabbles in sketching portraits, and drawing paintings and cartoons.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
The only negative aspect is that the book is a bit dated for certain topics, but that is just a small part of the book.
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 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.
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.
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.
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!
Most recent customer reviews
Lots of excellent real life code examples
Good reading for beginners to advanced users; helpful for advanced concepts but also built up to them...Read more