Professional restaurant supplies Spring Reading 2016 Amazon Fashion Learn more Discover it The Jayhawks Fire TV with 4k Ultra HD Made in Italy Amazon Gift Card Offer out2 out2 out2  Amazon Echo  Echo Dot  Amazon Tap  Echo Dot  Amazon Tap  Amazon Echo Fire, Only $39.99 Kindle Paperwhite UniOrlando ReadyRide Bikes from Diamondback May4th

Customer Reviews

4.6 out of 5 stars45
Your rating(Clear)Rate this item


There was a problem filtering reviews right now. Please try again later.

on July 30, 2010
I have a vast collection of SQL books. If it was published in the last 10 or so years, I probably have a copy. Some of them are very good, but there are quite a few similar-looking SQL books, with a similar purpose and a similar look-and-feel. So it takes some doing for a new SQL book to rise above the chaff... but SQL Antipatterns by Bill Karwin manages to do so.

This is not yet another book on SQL syntax or style. SQL Antipatterns is something altogether unique. The book is designed to point out the common things that SQL developers do, that they shouldn't be doing. Each chapter assists the reader in identifying, explaining, and correcting dangerous practices - or antipatterns.

If you take the time to read through this thoughtful book I'm sure you'll recognize some of the antipatterns. Some of you will have done them yourself, whereas others of you probably will have worked to undo some of them.

OK, many of you are still likely to be wondering what exactly is an antipattern is, right? Well, I'll give you one of the examples from Karwin's book -- Jaywalking. This is the first antipattern covered in the book and it is one of my favorites (err, I mean least favorites, I think). Jaywalking is when developers store comma-separated lists in a database column instead of redesigning the database structure in a normalized fashion. Karwin calls this jaywalking because both this practice and actual jaywalking on a street are acts of "avoiding an intersection." Funny...

Each antipatterns is described along with a clear explanation as to why it is a bad practice and advice on building a better solution. Other antipatterns covered in the book are named almost as intriguingly, such as Pseudokey Neat-Freak, Keyless Entry, Magic Beans, See No Evil, and Metadata Tribbles.

The book is not just for unlearning what you shouldn't be doing, it can also be helpful for learning new and improved development techniques. Reading SQL Antipatterns can help you to learn about current technology for full-text search, how to design code that is resistant to SQL injection attacks, and many other techniques for success.

The book is very well-organized into four parts grouping the antipatterns into the following categories: logical database design, physical database design, queries, and application development.

SQL Antipatterns should become a useful tool for DBAs and database programmers to help them create well-designed databases and applications... and to help us eliminate these common errors from our database implementations.
0Comment|46 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 9, 2010
I recently got a new job and inherited a vast collection of SQL queries to maintain. Reading Karwin's book has been a tremendous help! Each chapter considers a particular design issue ("How can I store more than one value in a field?") and shows the most common, flawed method (the "antipattern"). He carefully explains the disadvantages, then usually shows several other ways to accomplish the same goal.

One of the things I like best about the book is that the analysis isn't black and white. Every methods has advantages and disadvantages, which Karwin carefully unpacks. He also reviews and clarifies relational theory as he goes: his discussion of "Null" is a masterpiece. In general, he favors solutions that don't subvert the basic principles of relational database theory.

This would not be a good book to try to learn SQL or Database theory from, but if you are just starting to get some real-world experience it is a Godsend. Highly Recommended.
0Comment|34 people found this helpful. Was this review helpful to you?YesNoReport abuse
on August 24, 2010
I must admit that there was barely anything new to me in the book, but I have been in the field for quite a few years, dealing with many projects, so I had the "privilege" of seeing many horror stories. Still, I feel the book is valuable even for seasoned veterans. The main benefit is that the author organized and grouped the anti-patterns, each one is analyzed very well and contains some wise, unbiased suggestions. Each chapter stands on its own and can be read stand-alone.
The book is worth an extra star because it deals with problems related to both database's design and application developing; most book out there either cover one or the other.
This should be a mandatory reading for beginner DBAs and application developers, veterans may like it too, since it can help refreshing some concepts and can be used as a reference too.
0Comment|11 people found this helpful. Was this review helpful to you?YesNoReport abuse
on March 4, 2011
"SQL Antipatterns" by Bill Karwin is a collection of 4~7 page chapters, each neatly organized into:
1) Here's something people often need to do
2) Here's the stupid solution they often come up with
3) Here's why that's a bad idea
4) Here's what you should do instead

The nice, bite-sized chapters along with the "standalone" nature of each are reminiscent of "Effective Java," another favorite.

Among other cuteness, the author refers to foreign keys that relate to multiple tables as "promiscuous"... I give extra points to anyone who can weave a little innuendo into an SQL text.
0Comment|12 people found this helpful. Was this review helpful to you?YesNoReport abuse
on August 3, 2010
This book is very unique as far as database design and writing SQL statements. I could be called a 'cookbook' or a 'how-to' book, but its much more than that. The word 'antipatterns' means a way of doing something that is counter-productive in some form or another. So its basically of way to NOT do something. That may seem weird, but if you are aware of ways (patterns) that are ineffective, you will try to avoid those ways and be a more effectve programmer, developer, manager, etc.

There are lots of SQL and Database design books on how to do proper SQL statements but there are very few if any on showing students on what NOT to do with SQL. Its a great way to continue to learn SQL and Database design and advance your skills.

The author does an excellent job in going through all the phases of SQL antipatterns.

1. Rounding errors
2. Phamtom files
3. Index shotgun
4. fear of the unknown
5. random selection
6. spaghetti query
7. sql injection
8. magic beans
9. see no evil
10. ambiguous groups

The names may sound funny, but they are very informative and definitley worth understanding to realy be and efficient database programmer.

A great book and a must buy!
0Comment|9 people found this helpful. Was this review helpful to you?YesNoReport abuse
on September 2, 2012
Very easy read with good format. The book was more novice than I was hoping, overall, but I found a good chapter or two.

My biggest gripe is the application development chapter. The author likely should have stayed away from this topic altogether as the book just sort of bottoms out at this point. This chapter left much to be desired as far as application development principles and anti-patterns go. It wasn't that the points were not good, they were just intern / 101 level concepts that belong in an application development book. I would have never guessed the book would end on MVC.

All that being said, this is a must read for intern - junior developers everywhere, both database and application developers alike.
0Comment|7 people found this helpful. Was this review helpful to you?YesNoReport abuse
on June 23, 2013
I'm only page 80, but so far I love it. There are things us data guys know are sub-optimal or just plain wrong. Bill Karwin explains it so well in terms that the object guys I work with might be able to get it. A violation of first-normal form is "jay-walking" because you're avoiding the intersection (table.) I cringe when I see a self-referencing relationship. It looks so simple and elegant on paper, but it's usually the first step on a journey to a bad outcome. Bill Karwin calls this a "naive tree" and presents several alternatives. I wish I'd had the next three chapters about ten years ago when we created a persistence framework at work that used surrogate keys everywhere in a concrete to the bottom implementation of object graphs with relational intergrity turned off. If you're not a data guy or an object guy, you have no idea what that last sentence was about. If you are a data or object guy, buy the book and read it.
0Comment|2 people found this helpful. Was this review helpful to you?YesNoReport abuse
on January 11, 2013
While this book is interesting, well presented and written, and easy to understand, it doesn't cover enough ground to be the definitive SQL anti-patterns book.

In particular it just didn't cover enough ground on avoiding writing bad queries which is where a lot of anti-patterns in SQL make their way into production code.
0Comment|4 people found this helpful. Was this review helpful to you?YesNoReport abuse
on November 1, 2011
Once you've mastered, or at least think you have, the basics of relational databases, this is a good book to pick up. Karwin goes over the most common pitfalls of SQL database design and programming. As one that frequently has to work with someone else's database design I see these pitfalls over and over again. Some are obvious to any DB programmer worth his salt, some others, not so obvious and still others the subject of religious wars. I didn't agree with all of Karwin's suggestions or even what he identified as antipatterns, but that's fine. I've been using SQL since the 80's and I still learned something from this book. In our office, most of the programmers have to know enough SQL to make simple queries or at least to be able to decipher what some code is doing. This book will help eliminate the part that normally follows "to know enough", that is the "to be dangerous" part.
0Comment|2 people found this helpful. Was this review helpful to you?YesNoReport abuse
on October 16, 2010
I say surprisingly, because the active reader will think of numerous questions which the book never answers. I had to keep a notepad handy to jot down "but what about..." questions. This is actually a *good* thing. A book that not only teaches scripted lessons but also prompts the reader to create new ones is worth reading. As you would expect, the book assumes you know SQL, though not very much. If you can grok the basic joins and foreign keys, you'll have no trouble. I know exactly enough SQL to be a danger. I might say that if you're a serious RDBMS professional, you may not get much out of this. On the other hand, I've the victim^H^H^H^H^H^Huser of so many poorly designed "professional database solutions" that perhaps this book should be required reading. The author is not trying to "wow" you with SQL-fu. He deliberately keeps the SQL simple to clearly expose the (anti)patterns. I recognized several anti-patterns which I had learned the hard way in my own work and learned a few more to avoid.
0Comment|6 people found this helpful. Was this review helpful to you?YesNoReport abuse