Customer Reviews

The Guru's Guide to SQL Server Stored Procedures, XML, and HTML

5 star:		(68)
4 star:		(6)
3 star:		(3)
2 star:		(4)
1 star:		(2)

 

 

I never thought I'd say this but this book is even better than the first Gurus Guide book! Henderson cuts loose and just writes. It feels like you've got the guru sitting right next to as you read.

As with his first book, Henderson runs a tight ship with this one. There's no fluff or other filler material. Instead, you just get the goods, and you get them by the boatload.

My fav things about this one are:

* Extended Proc coverage. I've always wondered how to build these. The coverage in this book is absolutely excellent. It could be a book unto itself.

* XML coverage. I've never seen a better cut-to-the-chase introduction to XML and the XML features in SQL Server. It's a wonderful, hands-on tutorial written by a master.

* Emphasis on treating transact-sql as a real language. Henderson stresses this over and over and he's right. This book is every bit as good as the high-end programming books that feature languages like C++ and Java.

* Essays on software engineering. These are some of the best technical writing I've ever read.

I don't think you could spend your money on a better SQL Server book.

DjF

I bought the first Guru's Guide -- The Guru's Guide to Transact SQL -- as a way to fine-tune my SQL skills when I began a new job as a SQL Server Admin / Developer. Nearly two years later, I still find myself reaching for that book for almost every unique SQL problem that I encounter, and I am rarely disappointed. When I saw that Henderson had written another SQL book, I expected another winner. I was not disappointed.

The coverage of stored procedures, user-defined functions, and XML was first-rate. And the relatively short chapter on .NET was loaded with reasons why every SQL Server developer should be embracing this new techology.

The Essays on Software Engineering were extremely well-written. The intermingling of personal experiences and reflection with the technical details of the topics was done just right. It added a certain amount of relevance to the section that made it feel less like a theoretical lecture and more like the sharing of information by a well-respected colleague. One who has obviously experienced these things and knows what he is talking about. On the surface, these essays may seem a bit out of place in a book about Stored Procedures and XML but, in fact, they fit very well with the overall theme of the book: SQL and Stored Procedure development is "real" software engineering and needs to be treated as such if you are going to be good at it.

It's funny that no one thought of this before but the book has a message that is unique and new...writing code for Sql Server has to be approached like writing code for any other platform: as an engineering discipline. I had never heard this preached until I red this book, but am now a firm beleiver in it.

I have Henderson's other book and this one is a nice follow-up. there is naturaly some overlap between this book and the TSql book but not much. this one gets into coding conventions and version control, extended procs, design patterns and of course SqlXml...things the first book doesn't talk about. I look at this book as the big brother to the first one. It's more serious and more for the professional developer as opposed to being more of a dictionary of solutions to difficult TSql problems.

I also really liked the undocumented TSql chapter. This was my favorite chapter in Henderson's last book and this version of it has some new tricks and secrets. Just knowing about these will make you a better DBA because you will have a better understanding of what is happening under the hood.

Words can't begin to express what this book has meant to me. I am a developer who came to Sql Server late in life after a career writing COBOL, then DBase/Clipper, then FoxPro. I've watched the industry change, but have never really had the handle on all of it that this guy does. The book is ingenious. It takes Transact-Sql and gives it the hardcore language treatment. No one has ever done that before. I have all the other T-Sql books and, with the exception of Henderson's previous book, none come close to this one. You take Henderson's two Sql Server books and you have all you need to master Sql Server's programming language, Transact-Sql. Who talks about version control with Transact-Sql? Henderson does. Who gets into design patterns in stored procedures? Henderson does. Who discusses testing at length in an Sql book? Henderson does. Who shows how to add useful features to the language such as native array handling? Henderson does. Who would dare discuss how .NET relates to T-Sql development? Henderson does. Who talks about how eXtreme Programming applies to T-Sql developers? You know the answer. This is THE book to have if you want to master the T-Sql language.

This is the first SQL Server book that I can call a "real" programming book. It's not surprising that it comes from Addison-Wesley, the most prominent publisher of such books. In the spirit of Kernighan and Ritchie, Pike, Thomas and Hunt, Jon Bentley, and Erich Gamma, this is a thinker's Transact-SQL programming book.

It begins with a wonderful overview of all that is worth knowing about stored procedure programming in Transact-SQL. This is the best "in a nutshell" discussion I've seen of stored procedure programming. It is better than most whole books dedicated to the subject.

It moves on to coding conventions and source code management, two oft-neglected topics in the world of SQL Server. For some reason, most of us don't usually treat Transact-SQL as though it were true source code, but Henderson makes the compelling case that it is indeed, and he has convinced me.

Next, is one of the crown jewels of the book: design patterns. For anyone who has read any of the patterns books out there (e.g., Erich Gamma, John V., etc.), this will seem like an epiphany. You'll go, "Of course! Why didn't I think of that?!"

From here, we move on to database design. This is the best hands-on, practical guide to database design that I've ever seen. Henderson distills, in one chapter, all that you need to know to build complex business models, entity-relationship diagrams, and relational data models. What I like most about this is that Henderson doesn't start with physical modeling. He starts with the business processes the app that will use the database must encompass, then shows how to extrapolate business process flow charts, E-R diagrams, logical data models, and, finally physical data models. You start with nothing but an application concept and end up with a fully-functional SQL Server database. If you ever wanted to learn database modeling and design from the ground-up, this is your chance.

Next, is the objects section. Here, individual chapters cover Views (normal, partitioned and indexed), UDFs (lots of great code here including how to create your own system and vector functions -- e.g., MEDIAN()), triggers (normal, instead of, auditing), and error handling. Transact-SQL error handling is an oft-misunderstood area of the language. Henderson shines a light on it and shares what the masters know.

The SQLXML section is the second crown jewel of the book. When I saw that Henderson was covering SQLXML in his new book, I guess I should have guessed he would cut no corners, but, honestly, this section by itself is better than every other SQLXML book I've read. That's right - this one section of the book is better than other whole books dedicated to the subject. The introduction to XML is as good a synopsis of the language as you will find. The chapters covering the individual SQLXML features are also better than I've seen elsewhere. In true Henderson tradition, they are readable, in-depth, and thorougly engaging.

The advanced section is exactly that: advanced. Want to learn about how SQL Server interfaces with COM? Look no further -- the chapter even includes a nice, concise introduction to COM itself for those new to it. Want to learn to build extended procs? Look no further. This chapter alone is worth the whole cost of the book. I guess I shouldn't be surprised by now, but it's as in-depth as they come. I'm not even a C++ coder, but I worked through the examples and successfully built my first extended proc.

And I have to commend Henderson on the performance chapter. It's the best I've seen on the subject. It's far clearer and in-depth than what you find in Inside SQL Server 2000, for example.

The arrays chapter is the third crown jewel of the book. The technique of using extended procs and UDFs to add array support to the T-SQL language is ingenius. I'll bet Henderson could sell this code commercially if he wanted.

And the final crown jewel is the set of essays at the end of the book. What clear, lucid, lively, enjoyable prose. Henderson is one of the great technical writers of our generation. He spreads his wings a bit in these chapters and shows just what a great wordsmith he really is. Regardless of whether you're talking technical or nontechnical books, fiction or nonfiction, you will not find better writing than this. I think he should consider branching out into other kinds of writing because he obviously has the ability.

In sum: this book elevates Transact-SQL to the plateau of "real" languages such as Java, Pascal, and C++. It is the first "thinker's" coding book I've seen for Transact-SQL stored procedure development and among the best programming books I've ever read. It is a worthy successor to "The Guru's Guide to Transact-SQL."

There is a lot to like in this book. The chapter on database design is fantastic. The chapter on views is excellent as well. But overall the book veering off topic now and again, which adds to it's girth (760 pages.)

The book starts with a very solid introduction to stored procedures. As I say, the database design portion of the first part is probably worth the price of admission on it's own.

Part two is titled objects, which is a little deceptive since the chapter mainly covers functions, triggers, stored procedures and other structural elements.

Part three is where the book gets into XML and HTML. There is some introductory material on XML and XSL which is too brief to be a complete introduction for someone. That material is better presented in other books. But the material on XML queries direct to the SQL server is unique and valuable.

Part four on advanced topics has some good chapters. In particular the section on query optimization is well done and serves as a good introduction to the topic. But this part is where the book veers off course and into topics like testing, refactoring, XP, and an introduction to the .NET framework and C#. It's all interesting, but it's covered better in other books and the book overall could be shorter and more focused were it not for these sections.

Another downside is that Illustrations are a little underused. But the downsides aside, this is a great book, specifically for the first two parts including the excellent section on database design.

If you liked Henderson's first Guru's Guide book you will like this one as well. It has the same tone and same in depth coverage of useful topics.

The Data Volumes chapter was a real pleasure to read. The data doubling trick was worth the cost of the book all by itself. We switched to using it in our test suites and they sped up by 50%!

The chapter on Automation was also priceless. I love the sp_diffdb proc. I've needed to check two databases for schema differences many times over the years, but never had a tool for doing it. Now I get a free one with this book. That is some kind of value.

I also loves the Guru's Guide VSS tool. We use Visual SourceSafe in our shop, so this tool that integrates Query Analyzer with VSS was a godsend.

The .NET coverage was really eye-opening. You can tell the guy has definitely been there.

If you had the first Guru's Guide book get this one too. You won't be sorry.

I don't know why no one else ever thought of it before but this is the only book I know of that treats T-Sql like a real language. It teaches that you have to work at it to master it and follow a disciplined engineering approach to it to be really good with it. For example, the chapter on design patterns takes the patterns made famous by Grady Booch and co. and applies them to T-Sql. It seems obvious now, but I never thought of this before and haven't read any other books that cover this.

The Visual Source Safe integration is simply excellent. The book shows how to hook up Query Analzyer with VSS and even provides a tool to help manage your source code. I know a lot of shops that don't have any real management of their T-Sql code that would do themselves a favor to read an follow this chapter to the letter.

The Undocumented stuff is also really good. I had no idea half of these undocumented stored procedures, extended procedures, functions and DBCC commands were even in there. A couple of come in really handy, but mostly they just provide some insight into how the server really works which, like most of the book, is invaluable.

I own all three of Ken Henderson's SQL Server books. They stand apart from the rest of the crowd as the best books available on their respective subjects. Henderson takes a fresh approach to teaching that other authors would do well to emulate.

What do I mean exactly? I mean this: Every point of any significance that is raised is illustrated with code when possible. There are hundreds of code examples in each of Henderson's books - many times what you usually see in DBA or programming books. No details are glosssed over. If you really want to know how something works or what the best approach is to doing something, you need these books.

Another thing that is great about these books is how easy to read they are. Complex subjects are regularly broached with explanations and teaching that practically anyone could understand. Topics that trip up other authors or that they skip altogether are discussed in terms that anyone can grasp. It is difficult to convey just how important this is, but suffice it to say that the books are simply easy to read.

If you want to know SQL Server at an expert level, you need look no further. Get all three of Henderson's books and read them cover-to-cover.

I have been working as a programmer for 15+ years. I find this book to be an excellent balance of theory and practicality. I appreciate a writer who can give me an honest opinion, independent of the corporate party line, without taking a negative view of the product. I personally find this book to be much more readable than your average technical manual and it seems (to me) to indicate a depth of knowledge not readily demonstrated by most other authors who seem mostly to paraphrase the rather clinical books-on-line.

I found this book to be so helpful that I have purchased his other books on Architecture and Transact-SQL.

Before I purchased this book, I read several negative reviews, and was grateful for them. They convinced me beforehand (correctly) that this was the type of book I was looking for. If you are looking for a book with explicit solutions to every permutation of a problem, with code examples of how to solve "your specific" problem, this may not be your book. To me, those tend to fall under the heading of "give a man a fish" versus "teaching a man to fish". When I purchased this book, I was looking for a book that would explain things in a way that would let me know the ins-and-outs of this technology, showing me which things work, and more importantly which don't.

I have found chapter 3, "Common Design Patterns" to be an outstanding resource should be required reading for developers learning to write SQL "code".