Customer Reviews

Transact-SQL Programming

5 star:		(31)
4 star:		(10)
3 star:		(3)
2 star:		(12)
1 star:		(45)

 

 

You'd think this book covers SQL Server 6.5, 7.0 and Sybase SQL Server that this is going to be patchy here and there, trying to cover one product here and another product there. You'd think SQL Server 7.0 is so much more advanced than SQL Server 6.5 that this book has to make so many compromises that it's only half good for either. And you'd probably think that this book has so few pages, this must only be an intro.

Not so on all three accounts. This book is to-the-point Transact-SQL. There's no filler material here. I've programmed in Transact-SQL for quite awhile, and the examples, along with the descriptions, help me produce clean code. SQL Server is sensitive to how code and indexes interact. The author stresses the synergistic design of indexes and code.

Here is what you do have to watch out for if you're considering this book:

*This book is clearly a T-SQL only book. For example, it does not dwell on the exact page size; 6.5 uses 2k pages, while 7.0 uses 8k pages. You must be aware of this when you code and design indexes. This book covers the concepts very well, but it is up to you to apply the concepts to your design.

*Certain exciting additions such as Linked Servers are not discussed. The book is a bit backwards on the inter-operability of SQL Server, since Linked Server offers remote queries in addition to the functionality of Remote Servers (Linked Server is not available in 6.5).

*Replication is also not discussed. SQL Server 7.0 has greatly improved on the replication capabilities over 6.5, both in ease and reliability. In all fairness, replication is an enterprise architecture issue more than a coding issue.

Like all thick products, SQL Server (and Sybase SQL Server) deserves more than one book on any developer's/DBA's desk. I really like this book as a coding guide, but would definitely supplement this with:

*Inside SQL Server 7.0: performance tuning and deep understanding of SQL Server under-the-hood. This book is hard core.

*Books Online: excellent coverage on Replication, DTC, disaster recovery. Although not nice to read, I've had a hard time finding this information elsewhere.

*Deploying SQL Server: high level deployment guide.

T-SQL hasn't changed so much in 7.0 that its users cannot get a lot of useful information out of this book. For 6.5 DBA's, it is a *MUST* have book, no matter what your skill level.

Don't let the people who whine about it being focussed more on 6.5 than 7.0 scare you away. These people are obviously not managing real database installations because most of the professional DBA's I know (me included) are still managing 6.5 servers and will be throughout most of next year.

Buy this book if you want to be a DBA worth your paycheck.

I liked this book, but SQL 7.0 is covered in an appendix. Moreover, many of the techniques shown are archaic and have been deprecated by Microsoft, even for SQL 6.5. For example, joins are often show using the old join syntax. I wouldn't have such a problem with this if this book didn't advertise itself as a SQL 7.0 book. It's definitely not a 7.0 book and if you buy it expecting that, you'll be disappointed. Another problem with the book is its failure to adequately distinguish between Sybase and Microsoft syntax. There are some important differences, as the products have diverged more with each new release. Some of the examples show code that works on Sybase, but not on Microsoft (or vice versa), without telling the reader. The book would have been better off focusing on one or the other.

There aren't a lot of Transact-SQL books on the market, and when I saw that O'Reilly had one I had to have it. Whether you use SQL every day or just want to start learning... This is the perfect book. From the basics, to an in-depth understanding of the subject, this book acomplishes it all. Transact-SQL in a Nutshell is by far, the best 35 bucks I've ever spent. I use SQL every day, and this book has improved my developement time and quality by leaps and bounds. This one should actually get an extra star.

I remember SQL Server 4.2 and 6.5 well enough to know that this was a good book in its time. Problem is, 7.0 has been out for over a year and SQL 2000 is on the horizon. This book is woefully out of date. It queries system tables (in the first place, you shouldn't do that unless absolutely necessary) that don't even exist anymore (e.g., sysprocedures). It uses old-style joins throughout, despite the fact that they've been deprecated by Microsoft, Soukup&Delaney, Henderson, and many others. Last but not least, it *claims* 7.0 coverage, but does not deliver. A perfunctory appendix on 7.0 does not constitute SQL Server 7.0 coverage.

This is an outstanding book on writing Transact SQL. The changes brought by SQL Server 7.0 have little impact on the value this book provides to programmers that are new to T-SQL. The book is focused on writing better code, database design, and optimization. If you are looking for a book on SQL Server, this is not for you. If you are looking for an introductory level book, this book is not for you.

I bought this book because the cover said it covered SQL Server7.0. Really, it's just a 6.5 book with a single appendix on 7.0. Somany things changed in 7.0 that this makes the book virtually useless for 7.0 users. Basically, you pay money for one chapter and that chapter isn't really that good.

I'm a developer with some SQL experience who was new to Sybase ASE when I picked up this book. I found it very helpful and well written. I refer to this book every day, and it hass improved my programming skills.

This was the only book I could find that covered T-SQL for Sybase at all. Without it, I would have a hard time doing my job. However, I have found a few inaccuracies and code that will not work (check out ANSI-style joins and DEFAULT inside a CREATE TABLE to see what I mean). This is why this otherwise excellent book only rates 4 stars.

Transact-SQL Programming, by Kevin Kline, et al., is a very good SQL book, and an excellent Transact-SQL book. It covers Microsoft SQL Server 6.5/7.0 and Sybase Adaptive Server 11.5. (The changes in Transact-SQL from SQL Server 6.5 to 7.0 , by the way, are really not significant.)

This book is strongly oriented towards database programming, not administration. It's not for beginners. It's not a setup and configuration guide, nor is it a "cool features" book. And it's definitely not about how to hook up Visual Basic to SQL Server and call it database programming.

In order to get much from this book, the reader should be able to perform basic queries, inserts, updates and deletes using SQL. However, while some familiarity with SQL is presumed, the book has several chapters on "standard" SQL that is some of the best I've ever read for novice to intermediate SQL programming. (If you're entirely new to SQL programming get Joe Celko's Instant SQL book, or something like it.)

There are a few glaring typos throughout the book. I didn't perceive them to be any more frequent than in most recent computer books. Personally, I'd rather have the information in the book available a couple of weeks earlier than to wait for another proofread to shake out a couple of dozen typos. And furthermore, if the typos, in this book at least, are really throwing you, it's because you aren't understanding the material. Go back and re-read more carefully.

Once again, this is a Transact-SQL programming book. It is not a Microsoft SQL Server 7.0 book. If you don't understand the difference, you're probably not ready for this book. But if you want to learn how to use Transact-SQL to write professional, commercial database applications for either SQL Server 6.5/7.0 or Sybase Adaptive Server, this book provides everything you need to know.

Would extensive 7.0 coverage be too much too ask? I don't think so, and I don't think you will either. If you're like me, you'd come to this book expecting full coverage of the latest version of the language. Unfortunately, you won't get it -- it's not to be found between these covers. There's way too much time spent on the essoteric, and not nearly enough spent on the current version of the technology. First, they shouldn't be using old-style joins, particularly outer joins, because these can yield incorrect results. Second, they shouldn't be querying system tables directly when INFORMATION_SCHEMA views or system stored procedures will return the same info. Third, they shouldn't be delving into things like runnin bcp.exe from Transact-SQL in order to import data into the server - what a Rube Goldberg idea, especially when we have the BULK INSERT command built right into the language. Wouldn't waste my money on this if I were you.