The cover of SQL in a Nutshell sports a chameleon, the little lizard well known for its ability to blend in just about anywhere. This is a great choice for the Structured Query Language. SQL has been around since the seventies, helping developers interact with the ubiquitous relational database management system. Thirty some years later, SQL grinds away in the background of just about any interactive web site and nameless other technologies. New alternatives are popping up constantly but I’m going to go out on a limb and say that SQL is going to be around for a long time. Anyone interacting with an RDBMS is in all likelihood going to need to use SQL at some point. For those that do, who also want a handy desktop reference available, SQL in a Nutshell has been there for the last 9 years. The SQL language itself has not stood still over those years, and neither have the products that use SQL, and so now the book has is available in a third edition.

It’s pretty easy to sum up what SQL in a Nutshell contains. It covers the entire ANSI SQL2003 standard as well as how that standard is implemented in MySQL 5.1, Oracle Database 11g, PostgreSQL 8.2.1 and Microsoft SQL Server 2008. There is a new ANSI standard more recent than the 2003 standard, ANSI SQL2006. This new standard does not change anything covered in the book, but introduced XML and XQuery which are not covered here. The format for conveying all this information mirrors that of the other “…in a Nutshell” books. There are four sections. The first is a very short (15 pages) history of SQL and the second is a summary of foundational concepts. The vast majority of the book is the third section, “SQL Statement Commands.” These commands are given in alphabetical order. There is also a table at the very beginning of the chapter listing every command and showing how it is supported by the four platforms.

Each command is presented by starting with a short summary of what it does. This is followed by a table showing which RDBMS products support the command, the proper syntax for the command, key words, command rules, possible issues that may come up and implementation details and examples for each of the four RDBMS products represented. A couple of the differences between the second and third edition are that two RDBMS products were dropped and there are more examples. The products dropped allowed for there to be more examples while also making the book smaller than earlier editions. Anyone working with Sybase Adaptive Server or DB2 UDB will want to hold onto their second edition copy of this book if they want to have that platform specific content available, because it is not in this third edition.

The book states that the dropped platforms were the least popular of those in earlier editions. For those wondering why their favorite RDBMS is not in the list, that gives the answer. To keep length down the number of specific platforms covered was kept to four. Fortunately the books is still of high value for most readers as most decent RDBMS products will support ANSI SQL standards. On those occasions they do not, the reader would have to look to another resource for help. The length issue is easy to understand when looking at the GRANT statement and seeing that it covers over twenty pages. Most of this space is used to explain the various options available on each platform.

The last section SQL Functions documents all of the standard functions with examples and then contains a list of platform specific extensions, grouped by product. There is not a table showing platform support like there was for SQL statements. This section is much smaller, so it really isn’t an issue. The single appendix that follows list standard and platform specific key words.

So who would benefit from SQL in a Nutshell? The most obvious to me is the DBA or developer working across more than one of the four platforms presented, especially if they don’t move from one to the other too often. Like an Oracle DBA that needs to go do something in MS SQL Server every so often, or the same type of thing between any of the others. This makes for a quick resource that will sort out forgetting how one or the other does things rather quickly. But even if one isn’t moving across multiple platforms, unless the whole standard has been memorized, this is a great help.

The second group I see gaining some real good from this book are those new to working with SQL. I’ve worked with all four platforms and others not covered in this book and on every single one of them I’ve hit error messages that were anything but helpful. Being able to go directly to a correct statement of syntax and usage is a real help when the system doesn’t want to tell what is really going on. It is important to remember that this is a pure reference book. It is not written with the intent of teaching how to use SQL. That said, it covers the entire standard. Much like a dictionary can be used to increase one’s knowledge of a language, reading through this reference can be a good way to learn more about SQL. Many introductory texts aren’t going to cover the whole standard or as many platform specific details. The student of SQL would get a real jump by working through this book. It is compact enough that while it wouldn’t be a thrilling read, it is completely doable.

Who wont like it? Probably anyone who doesn’t like any of the other nutshell books from O’Reilly. This book is pretty much exactly like my Unix in a Nutshell, Linux in a Nutshell and MySQL in a Nutshell books. If the format and approach bothers you, don’t look for any radical departure that will make it more palatable here. If you are like me and already know you like the format, then this is pretty much a sure thing. For the vast majority of us that work in the database world, this is the reference. I say this keeping in mind the scope of the book. Is this everything one needs to know about SQL? Obviously not. There is much more to be said about SQL as evidenced by all the words that have been said and are out there in print. But when one wants to know quickly about SQL statements and functions, I can’t think of a better resource.

Title: SQL in a Nutshell, 3rd Edition
Author: Kevin Kline, Daniel Kline, Brand Hunt
Publisher: O’Reilly Media Inc.
Pages: 590
ISBN: 978-0-596-51884-4
Rating: 10/10

Princess Ruruna, of the Kingdom of Kod, has a problem. Her parents, the King and Queen, have left to travel abroad. Ruruna has been left to manage the nations fruit business. Much is at stake, Kod is known as “The Country of Fruit.” Ruruna is not happy though, as she is swamped by paperwork and information overload. A mysterious book, sent by her father, contains Tico the fairy. Tico, and the supernatural book are going to help Princess Ruruna solve her problems with the power of the database. This is the setting for all that takes place in The Manga Guide to Databases. If you are like me and learned things like normalization and set operations from a rather dry text book, you may be quite entertained by the contents of this book. If you would like to teach others about creating and using relational databases and you want it to be fun, this book may be exactly what you need.

I was pleasantly surprised by this book. It really does do a great job of introducing relational database management systems. All the SQL is ANSI standard. (Except for one exception, joins, which I’ll discuss later.) There is no mention that I could find of any certain RDBMS product. Barring any proprietary quirks, everything in here should work on just about anything from Access to Oracle. Teamed up with PostgreSQL or MySQL, I think that one would have everything they need to teach an extremely inexpensive (materials wise anyway) class on building and using databases. I think that the manga format would make it especially attractive to younger people. By younger, I think high school age students would really enjoy it and I think even college students would find it to be fun if they weren’t too stuffy. If I were teaching professionals, I might worry that they wouldn’t take it seriously, but the content is solid and anyone who can lighten up can also learn from this book.

It is an introductory level book. I wouldn’t hand this to an entry level dba and turn them loose on a production system. It teaches what a relational database is, about the entity/relationship model, using standard sql, as well as transactions, recover, indexing and query optimization. That’s a pretty decent foundation. There is also a final chapter that is half manga and half more traditional straight text. The manga section gives some information on real world uses for databases and wraps up the story. The second section covers things like multi-tier web applications, stored procedures, triggers, partitioning and replication. It does this all rather quickly and basically just gives the reader an idea of what the terms mean. There is no information on actually implementation details. It wouldn’t have made sense anyway as this would have necessitated leaving the generic approach taken in the rest of the book to discuss specific RDBMS products.

The art work is well done and the side story of Ruruna, her assistant Cain and the fairy Tico is entertaining if a bit silly. I thought that it really helped to take what is really dry subject matter and lighten it up. It also introduces examples of real world situations that are being modeled in the data. They are a bit contrived as all examples are in these situations, but they still help to reaffirm how the various pieces fit together so that databases can be helpful. Each chapter picks up with the story and is graphics heavy. This is followed with a by a review section that reverts to a more text heavy mode and then there are review questions. The answers to the questions appear immediately following the questions. I think it would have been nice to have them further removed, so that one wouldn’t have any opportunity to see the answers on accident. That said, the review and quiz do a nice job of letting one gauge if they have really picked up the material. If the quiz is a struggle, it is safe to say that going back over the chapter would not be a bad idea. The questions are pretty straight forward and apply the material directly. They are not vague or wishy washy, so not knowing the answers means the reader doesn’t know the material.

As I mentioned, the books sticks to standard SQL. I was happy to see this. The only change I would make is that joins are done in the old style as a part of the where clause. The book discusses various types of joins but does not give examples of anything but a normal inner join. This may help someone considering this book to get a good feel for just how far it goes. I found the information on transactions, locking, and indexing to be very good. I really didn’t expect much in this regard, but I’ve worked with experienced, decent developers that I think would learn some things from this book especially about rolling back transactions and the limits of recovery. (Of course these are the situations where DBAs and developers are going to have some of their more interesting interaction. My bonus tip of the day is the developer that calls you in the morning about the database problem, is the one who caused it right before he went home the night before.) That said the discussion on recovery is vendor agnostic like the rest of the book and so there are not really any implementation details. The indexing section is also a bit brief and while it does a good job of explaining what an index is, I think there is too much emphasis on them increasing read speed with enough emphasis on how they may not do that at all and how they can hurt writes. These things are all mentioned, but very briefly.

If I were teaching teenagers or even lower class college students, I wouldn’t hesitate to build a class around this book. I think that the amount of fun and heightened interest it could bring to the table would far outweigh the need to supplement the book’s few shortcomings. I like that it does not tie the reader to any database product. I would also not hesitate it to a friend who wanted to learn on their own. I think someone has much higher odds of making it through this book compared to the textbooks on relational databases that I had to work through in school. But it is just an introduction. It gives the readers the tools for basic interactions with a database, and a handle on the basic terminology of database administration. Assuming that one will get more than that could lead to trouble. All the way around this is a solid book and I wish there were more like it in the IT world.

Title: The Manga Guide to Databases
Author: Mana Takahashi, Illustrated by Shoko Azuma
Publisher: No Starch Press
Pages: 220
ISBN: 978-1-59327-190-9
Rating: 9/10
Tagline: Unleash the power of the database.

My past as a DBA probably makes me a bit biased, but the reaction I’ve seen the most when a database application isn’t performing as well as would be liked seems to focus on the database side of things. The search for a solution usually seems to center around tuning db parameters, the building (or removal) of indexes and if the budget allows, throwing hardware at the problem. In their new work, Refactoring SQL Applications, Faroult and L’Hermite bring a much wider range of options to the table. There is a lot in this little book for the developer charged with fixing an existing application and I think a lot of good information that could save one from making a number of head-ache inducing mistakes on a new application.

The book is divided into eight chapters the first two deal with how to approach a problematic application in general. In the preface the authors say, “This book tries to take a realistic and honest view of the improvement of applications with a strong SQL component, and to define a rational framework for tactical maneuvers.” I found this to be true throughout the entire book and was impressed by how well the examples, suggestions and problems echoed my real life experience. This book is first and foremost practical. There is really almost nothing in the book that does not come immediately to bear upon the problem at hand. I’ve seen others do a lot less with many more pages.

The examples and benchmarks are compared across three different popular relational database management systems. They are MySQL, Oracle RDBMS and Microsoft SQL Server. I thought that this brought up a couple interesting issues that are not directly addressed in the book. First is that the authors are talking about how to improve performance, not comparing platforms but the numbers are there and may be of some interest to people who would like to compare them. Secondly, I’ve met a number of people over the years who get quite animated about insisting that a good DBA does not need to know any certain solution, but rather just the fundamentals. I think Faroult and L’Hermite put this idea to rest, though unintentionally. In order to discuss how to best understand what exactly is happening and how best remedy issues, they show that it is necessary to have an understanding of platform specific issues and tools. This is true on two levels. The first is that the location of use of the built in tools for each platform are different. The second is that what works for one platform does not necessarily work for another.

For example, Chapter Two “Sanity Checks” contains a section on parsing and bind variables. The authors compare performance when queries are hard coded, with new prepared statements on each iteration (firm coded) and with one prepared statement and changing the parameter value on each iteration in a loop (soft coded). On Oracle and SQL Server the performance was poorest with hard coded, better with firm coded and best with soft coded. MySQL did best with soft coded as well but actually took a performance hit moving from hard coded to firm coded. This had to do with differences in how MySQL server caches statements. The authors took the time to rewrite their code from java to c in order to ensure that the issue was not related to language or driver issues. This is not to say that one can ignore RDBMS and SQL fundamentals, but rather that to get top performance requires knowledge of platform specific issues. This also comes out again when dealing with optimizers.

With that in mind, the authors recommend that readers have a solid understanding of SQL and some programming language. Most examples are SQL and code is given in Java and PHP. There are also examples that illustrate SQL extensions showing procedures, functions, etc. written for all three RDBMS products covered. The authors stick primarily to standard SQL but do make note and at times show examples of how things will look in each of the other databases. This information is current and reflects the most recent versions of the each product.

The fourth chapter, “Testing Framework” is incredibly useful. The authors cover generating test data and then checking correctness of outcomes through comparison. This is really useful information for anyone working to improve an application, or writing one for the first time. I think it also a large part of why this book could really appeal to new and experienced developers as well as the developer working on existing or brand new applications. I think there is a good chance that only the most extremely experienced developer would find nothing new here, or at least some new way to approach a problem. New developers can learn quite a bit and avoid some bad habits and assumptions without having to gain that information the hard way. And then the tools for generating random data, large amounts of data and comparing results will provide excellent opportunities for learning and real world application.

The next three chapters cover dealing with specific types of issues and how to improve performance. The last chapter then quickly describes a scenario of just how the authors step into real world situations and start to attack a problem. This is followed with two appendices. The first is scripts and samples, the second tools that are available to help in finding issues and resolving them. Some of the authors tools use SQLite, which is discussed briefly in the chapter on creating test data as some of the tools depend upon it.

I think that it has been a while since I’ve read a book that could have such a rapid return on investment. There are many suggestions and insights that should enable anyone to squeeze better performance out of just about any database application. While the focus is on the application side, there is plenty that requires understanding and work on the database side as well. There is discussion of the parameters and hardware I mentioned at the start of this review. But rather than the only options, they are one part in a much larger and systematic approach.

The authors relate that often refactoring for this type of application comes into play when something that used to work does not work any more. This can often lead to an environment of high pressure and emotion. The desire for a rapid resolution can lead to casting about in the dark for a quick fix or a feeling that cost is no longer as significant since a fix must be had now. The authors argue, and I agree, that this is exactly when a rational, disciplined process of tracking down and fixing issues is the most valuable. I agree. The issue is of course that someone in a position to do something must have the ability to take that approach. This book will get one well on the way to being in that place. Of course it can’t take a brand new developer or DBA an expert. Much like a degree it can give them some fundamental tools that will allow them to take full advantage of experience as it comes rather than just crashing and burning.

If I could I’d have any developer on a database centric application read this, and DBAs as well. There is a lot here for both sides to learn about just how much they depend upon and impact one another. This may be an idealistic dream, especially for larger shops where often the relationship between those two groups is adversarial, but I think that such an approach could only make life much better for everyone involved. For anyone looking to enter this world on either side of the DBA or developer equation, this may make a nice addition to their education. For that individual wearing both hats this could be a life saver. In this small book they will learn many things to look out for as well as gain exposure to some of the similarities and differences in what are arguably the top three relational database management systems right now.

Title: Refactoring SQL Applications

Author: Stephane Faroult with Pascal L’Hermite
Publisher: O’Reilly Media, Inc.
Pages: 293
ISBN: 978-0-596-51497-6
Rating: 9/10

MySQL is frequently touted as the world’s most widely used relational database management system. Many of the worlds most well known web applications and web sites use MySQL as their data repository. The popularity of MySQL has continued to grow while at the same time many were taken aback by the lack of many features considered to be essential to a ‘real’ rdbms. Such naysayers have done little to impeed the growth or development of MySQL. The first edition of MySQL in a Nutshell, published in 2005 gave users a handy reference to using MySQL. The second edition published in 2008 with coverage of many new features that MySQL fans proudly proclaim as an answer to all those critics clamoring for a more well rounded rdbms.

O’Reilly’s Nutshell books normally ecompass two types of content; tutorials and command reference. MySQL in a Nutshell is true to that format. In this book though, the line between the two is not as cut and dried as in some of the other Nutshell books. The closest to pure reference is probably the documentation of MySQL functions. But there is always more than just a simple statement of function name and parameters. There are examples and when appropriate, Dyer explains function behavior beyond the inherently obvious. A good example would be when Dyer explains the output of Sleep() in the case of a user interupting query execution with crtl-c.

The tutorials cover all of the basics but extend well into the meat of succesfully administering an rdbms. The book begins with an introduction to MySQL itself, instructions on installation and a brief overview of the basics. These chapters make up the first section of the book and take up 35 pages. This means that the book is not an introduction to sql or using an rdbms. This book is first and foremost a reference for the MySQL user who has already moved past the introductory level. I don’t think one needs to be an expert to use the book but there is no extended hand-holding for the novice. This is a plus in my opinion, rather than the publisher shoving in a bunch of extra material in an attempt to make the book useful to every reader regardless of their level of experience.

The second section, “SQL Statements and Functions”, understandably comprises the majority of the text. This second edition breaks down the categories further, leading to an additional five chapters when compared to the first edition. This is evident with the first chapter, “Security and User Statements and Functions” a chapter that was not in the first edition. Here again the real strength is that the commands are not just documented but they are explained and illustrated with examples.

For the person already working as a MySQL DBA or aspiring to do so, there is excellent coverage beyond the basics. There is documentation on essential skills like back-up, recovery and replication. Another new chapter breaks out database table and schema commands on their own. The brief, but thorough documentation of these features makes this volume extremely useful to the DBA moving to MySQL from another rdbms. One struggle for me, coming to MySQL from Oracle has been that sometimes things are just done very differently than I expect. I don’t need a lot of background, I just need to know the MySQL method and this book makes that quickly available and gets me running until I have time to dig further into the why. I would think that this book is a must on the bookshelf of any DBA responsible for the care of MySQL.

Section three further shores up this use with very thorough documentation of MySQL server and client tools. Chapter 15 covers mysqld and mysql. Chapter 16 covers command line utilities. There are roughly 30 utilities coverd and I am sure that this chapter could be a real life saver for many. The book does not cover the gui tools available for managing and working with MySQL. This is a strength in my opinion. The tools are built on top of what is documented here and knowledge of the command line commands should adequately prepare the user to deal with any of the various gui tools available out there. This may be somewhat disconcerting to anyone coming from a MS SQL Server background. It’s been my experience that folks who have only worked with MS SQL Server struggle when they don’t have gui tools, whatever rdbms they are on. Fortunately for them there are a lot of options available to manage MySQL with a gui, they just aren’t covered in this book.

The second group that could benefit the most from this book, beyond database administrators is the devloper. The documentation of sql statements and functions is of course very useful. The fourth section covers APIs and connectors. It documents the c, perl and php APIs. These chapters follow the same easy flow of mix between documentation and tutorial. The beginning of the chapter covers the basics of connecting, executing statements against the database and the reference follows with the specifics of commands and accompanying examples.

Section five contains three appenices that cover data types, operators and server/environment variables. All three are concise but valuable and cover the information fully. The index does an excellent job of covering not only specific terms but subjects and makes it easy to find what the reader wants, even if they aren’t sure of the specific command they are looking to read about.

The book is based on MySQL 5.0 and makes note of features that will be availble in 5.1 and 6.0. This does not include master-master replication, since I mentioned that the book does cover that topic. But the section on replication will still be of use with that new feature I am sure. There were some formatting issues in my copy. I don’t know if it was isolated or a part of a larger number of copies, I did not see it mentioned on the errata web page for the book. In the chapter on date and time functions, three of the sql examples have formatting errors. The last three characters of the last line of the example are repeated as a fourth line. I’m not sure how this crept in, and it is pretty easy to see that the characters are a typo as opposed to part of the statement but it did throw me for a moment when I looked at them. Anyone typing the command verbatim will get an opportunity to see what their client does with incorrect sql.

I think that this is an excellent book that will aid anyone who interacts with MySQL on a regular basis. There is no fluff, no cuteness and no attempt to do anything beyond providing quick access to key information. The book hits that sweet spot between providing too much or not enough. It does not try to be everything to everyone as I mentioned. It will not do all the lifting necessary to get someone who does not even know what an rdbms is to where they will need to be in order to make good use of this book. It does not dive deep on internals or more advanced topics. But what it covers in that wide middle, it covers very well.

Title: MySQL in a Nutshell
Author: Russell J.T. Dyer
Publisher: O’Reilly Media, Inc.
Pages: 561
ISBN: 978-0-596-51433-4
Rating: 9/10
Tagline: A Desktop Quick Reference

It doesn’t seem like it has been 3 years since the Mambo dev team split and a new content management system, Joomla! was born. Over the last few years Joomla has grown to be very popular and has very strong developer and user communities. Joomla is extremely flexible and a wide array of extensions exist that allow the system to provide many different capabilities. In “Joomla! A User’s Guide”, Barrie North provides everything needed to get anyone up and running with a Joomla based site, even if they have little or no experience with creating web sites or applications.

The book is written with language and content squarely aimed at someone new to the tech side of building and running a web site. The language is very simple and even relatively basic terms are explained. As someone with some amount of experience working with software and the web, I didn’t find it to be tedious. North does not go on at length, but just gives the information necessary so that someone without the background will be able to keep up. He can also be rather sympathetic to the reader, encouraging them with things that he says can be difficult. That did get a little tiring at times, though I would imagine for his target audience these affirmations could be really assuring. If you are someone who just wants to get a jump on how Joomla works, I wouldn’t worry too much about this emphasis on the basic. The book is not overly verbose and so the more basic content does not seem to stretch on forever. North covers a lot of ground in what is a thin book in comparison to much of what seems to dominate the tech book market these days.

While North doesn’t wallow in the most basic material and explanations, he never moves on to the really advanced stuff either. If you are interested in coding extensions, or working with the core code, you wont find much here. If you would like a definitive guide with an explanation for every feature and option that exists in Joomla you wont get that either. What North provides is a guide to the most used and most useful information about how to install, set up and run a Joomla based web site. Probably the most advanced material in the book deals with building templates for customizing the look of Joomla. Along with instructions on working with Joomla itself, North also takes some time to also deal with how to generate traffic to a site. For some that chapter may be a bit uncomfortable, though North does a good job of laying out a basic explanation of how things work, as well as practices to avoid. There is a matching appendix on SEO, which is a dirty word in some places. I think that North approaches it with a nice balance between reaching for visibility while avoiding actions that are less than desirable.

The book ends with 3 example sites that the reader can be built as they work through the book. These cover a nice range of cases with one being for a school, another for a business and the third is a blog. This gives the reader nice opportunities to play with the software while having guidelines that keep moving things forward and give it all some useful context. A nice companion to this is an appendix with six case studies on existing sites that use Joomla. North interviewed someone from each site and gives an introduction to the site, a screen shot of their front page and then the questions and answers about the site. Together this forms very nice coverage on just what kind of possibilities exist from a real world perspective as opposed to keeping everything purely theoretical.

The book tends to lean towards explaining platform specific items, like installation, from the Windows perspective. I think the assumption is that Linux users will probably already know how to install what they need and are quite likely to already have all the supporting pieces in place. North explains the installation of WampServer for windows users, to get them started with a local install for working through the book. Everything is very hands on and while the screen shots are not in color they are clear and easy to understand. There are also highlighted notes that give the reader reinforcement on what is most necessary to take away from a section.

The support for the book outside of the copy itself is very good. The book comes with 45 days access through Safari. North’s site for the book has downloads for the associated files from the book as well as sql dumps from the MySQL databases that correspond to the example sites from the book. Everything necessary to build out the examples in the book, or compare one’s work to the authors should problems creep up.

I consider myself to be somewhat technically proficient and at times I did find myself skimming over material that I didn’t need. But I did want to use Joomla well and gain that skill quickly and this book was very helpful in that regard. I would think for anyone else who didn’t want to waste any time hunting around, this could be a useful guide. Another good use I could see for the book is that it would make an excellent gift to anyone who is not a ‘geek’ but is using a joomla based site. This could be a client that has a new site you just built for them, or a relative or friend who would like to have a site of their own but seem to call you for support a little too often. I know if I hand off a Joomla site to anyone in the future, unless they are already experience with it, they will be getting a copy of this book.

I’ve given the book a final rating of 8 on a scale of 10. I do so for two reasons. The first is that Joomla is constantly under development and it is more than likely that in a couple more years or less these instructions will need a major over haul. The second is that while the information on generating traffic was somewhat interesting, I’d have gladly traded it for more information on Joomla itself. Those are relatively minor complaints and from what I’ve seen, this may be the top Joomla book available right now.

Title: Joomla! A User’s Guide
Author: Barrie M. North
Publisher: Prentice Hall PTR
Pages: 480
ISBN: 0136135609
Rating: 8/10
Tagline: Building a Successful Joomla! Powered Website