Customer Reviews

Refactoring SQL Applications

5 star:		(2)
4 star:		(2)
3 star:		(0)
2 star:		(0)
1 star:		(1)

 

 

Faroult and Hermite focus their attention on relatively classical SQL optimizations. The gist of their advice is that developers running SQL code need to leverage the database engine's optimizer. To do that, they offer relatively common advice: use set operations, avoiding procedural code in your sql code whenever possible; minimize the number of visits to a table; and minimize the number of times your code has to scan a given table. Most of the content of the book is spent offering techniques for achieving these objectives. For developers without a lot of experience writing SQL intensive applications, the authors provide a relatively accessible discussion of these techniques.

Outside of that, the authors include a chapter called `Testing Framework' that addresses one of the key requirements of any refactoring effort: creating and maintaining a library of unit tests that allows us to prove that our code is correct. When writing database code, and particular code whose performance may vary based on the amount of data being processed, unit testing can be a bit of a challenge due to the typical case where developers are developing locally on databases that contain small data sets. In this chapter Faroult and Hermite offer some data generation techniques and some mechanisms for automating the comparison of resulting outputs.

What I like about this book is that unlike books on optimizing the performance of a particular database product, this book tries to elevate the discussion to the level of optimizing the performance of an application that contains a substantial amount of realistic database code. It should enable developers to analyze their code in the context of the business objectives that it is trying to fulfill, rather than the context of the database engine in which it is executing. For that reason alone, I am recommending it to the database developers on my team.

I'm at odds with the first two reviewers, but I think it depends on what you're looking for. This book is NOT about classical tuning. Classical tuning is "tune the server", and "tune the query".

The emphasis - in the preface and the excellent Chapter 6 - is that the real gains are usually elsewhere, when you have older code.

I work with a 25 year heritage of fairly well written apps. Many of them have the described situation - a single query that's been broken into two or more parts, with an outer loop and (at least one) inner loop. When server memories were 64K, or 1 Meg, or 4 Meg, and CPU's only came in packages of 1, and disk channels were slow, and networks were slower, this was often the only practical way to get a result.

The interplay changed over the years, but the old code worked. In the past few years, with 64-bit processors, cheap 64-CPU servers, and multi-io disk channels, a wierd thing happened. We found that moving to newer systems and faster hardware made things run SLOWER.

The answer time and again was in those "split loop queries". If we turned them back into one big query - the kind that you couldn't run before, we would see performance improvements of hundreds or thousands of times. In the end, the math proved - on powerful machines, most of the overhead is sending the query, compiling it, and sending it back. If one monster query takes a full second, but every query in the loop takes 1/4 second - if that inner loop runs 1000 times, you lose.

Meantime, that 64-core machine has every CPU working full blast - recompiling the same stupid statement over and over! The problem is, you try to tell this to a developer, they don't beleive you "I didn't change anything in the code".

And that's what this book is about. Changing the code. This book validates what I've been trying to tell my managers and coders; I am grateful to Faoult and L'Hermite for showing I was not making this up myself.

The second reviewer is just reading the wrong book for whatever it is they are trying to do.

This is an essential book for certain people, and is certainly of no interest whatsoever for others. (If you don't own a 1941 Plymouth, the 1941 Plymouth manual isn't much use - otherwise, it's a must).

Any application that accesses a database will eventually present you with queries that run much slower than is desirable. This book provides you with a guide to how to resolve such problems and get your database accesses to run faster.

The most often suggested solutions are not always the correct ones and this book clearly demonstrates several situations where doing what appears to be an obvious fix (such as adding an index) may actually make things worse.

The author of this book has an in-depth understanding of how databases really work and as a result of the explanations that are provided in this book you can leverage on that to improve the performance of your SQL without needing as complete an understanding as the author has. If anything the book will actually help to give you a greater understanding of how databases work.

Are you going to know where to look when you next have a progr

"The application design is the most important factor in performance"
I've heard the phrase so many times, it doesn't even register on me. Sure the application design is the most important factor in performance, but what do I do about it? Well, "Refactoring SQL Applications" (RSA) is the book I've been waiting for. RSA lays out examples of how application coders tend to think either procedurally or object oriented and how this thinking can completely miss the boat when it comes to writing SQL and interacting with databases.
In RSA, Stephane Faroult, lays out examples of Java code, user defined functions and views and how a coders notions of modular procedural programing and/or object instantiation can undermine database performance from cookie cutter reuse of code to table joins written in Java. If you've ever seen Tom Kyte's "Developer Super Session - The Best Way", then you know the best way is not to do it all and his example is coders doing "count(*)" to find out how many loops to do or how big an array to layout. Tom explains the disasters this can create and how the best way is just to not do the count(*) and how this works by letting the database do the work. Letting the database do the work is explained clearly and with many examples from different perspectives in "Refactoring SQL Applications".

Performance tuning of a database application is a minor part of refactoring a SQL application. In 2008, many programmers found themselves inheriting large applications running on thousands of stored procedures written in PL-SQL, TSQL - great stuff during the hey days of client-server programming era circa the 80s and 90s. For those who are looking for a book to help with the re-design, re-plumbing i.e. refactoring of SQL applications, this book will not help much.

Much of this book is focused on the issue of tuning data model, tuning SQL queries etc With the current server processing power, caching, bit-mapped indices, and a plethora of SQL tuning tools, performance tuning is no longer such a major concern in a SQL refactoring project.

If you are looking for discussion on building unit tests, building wrapper, sprout, identification of seams etc, you should look else where.