Customer Reviews


11 Reviews
5 star:
 (3)
4 star:
 (4)
3 star:
 (3)
2 star:    (0)
1 star:
 (1)
 
 
 
 
 
Average Customer Review
Share your thoughts with other customers
Create your own review
 
 

The most helpful favorable review
The most helpful critical review


37 of 38 people found the following review helpful
5.0 out of 5 stars Substantially more than a style guide.
Style guides tend to be heuristics of understanding a hard-to-define -- consequently hard to defend -- criteria that will make your design effective. Strunk's "Elements of Style" would be an exemplary definition of a style guide. With all style guides, however, you can follow them religiously and still end up with an execrable book or living room.

Mr. Celko...
Published on May 15, 2005 by Christopher Wanko

versus
12 of 12 people found the following review helpful
3.0 out of 5 stars 3.5 stars: Has good stuff but very undercooked
I'll expand on that when I have time; but for now, real quick:
PROs:

- As usual for Celko's books, you get this feeling of conversing with a knowledgeable and overall very likeable individual with a good sense of humour (he got me laughing on page 2, see his comments on the making of fine furniture).

- Good justifications are given for many...
Published on March 26, 2007 by J Jacob Jingleheimer Schmidt


‹ Previous | 1 2 | Next ›
Most Helpful First | Newest First

37 of 38 people found the following review helpful
5.0 out of 5 stars Substantially more than a style guide., May 15, 2005
This review is from: Joe Celko's SQL Programming Style (The Morgan Kaufmann Series in Data Management Systems) (Paperback)
Style guides tend to be heuristics of understanding a hard-to-define -- consequently hard to defend -- criteria that will make your design effective. Strunk's "Elements of Style" would be an exemplary definition of a style guide. With all style guides, however, you can follow them religiously and still end up with an execrable book or living room.

Mr. Celko spends remarkably little time with style formatting, although he does delineate what constitutes readable and maintainable SQL code. Where the book finds its utmost utility is in the consistent and increasing reinforcement of thinking in sets. SQL is not about transforming data (although you can); SQL is about properly storing data, and then being able to find it again. Simple enough, but all-too-easy to get wrong.

The first two chapters talk about naming and actual SQL style. This is primarily what I'd expected, but Mr. Celko isn't about to let me off that easily. In discussing naming, he brings international standards into the mix. Right away, the standard of my existing SQL code falls away under this level of scrutiny. Throughout the book, Mr. Celko is bringing up a data discipine I have long-suspected existed but honestly never sought to embrace. Why should I develop a data model that adheres to standards, if mine will be the only model in the company even attempting it?

Therein lays the problem with this book: it can make a reader uncomfortable. Mr. Celko is writing about SQL and, more importantly, the data it will describe and manipulate, in far more depth and with far more rigor than I've seen elsewhere. He has an entire chapter on encoding data, another on scales used to measure data. Nowhere else will such treatment be gathered in one place, in the context of using SQL. Moreover, his conclusions are backed by years of experience *and* impressive references to back him. The bibliography will surely cause me to invest in yet more books.

Of course, the book can be dry in spots. Encoding data properly is important, but it's not as entertaining as seeing his effective SQL examples put to work. I think the balance between showing data as it is displayed and explaining the theory of the encoding (or modeling, or selection) is tricky to achieve, but I don't believe it ever broke down. The *density* of the book is striking; going into a 195-page book, you don't readily expect to re-read the same page three times to grasp something, but you must. At some point in the book, you will encounter an aspect of SQL development you've never come close to mastering, and it will give you pause. Take notes, work it out, and dig deeper. It'll be worth it.

Could I recommend this to newcomers to SQL programming? Qualified yes; you need to discipline yourself to work through much of it if you lack the experience in what's being presented. The book would make an excellent two-semester course in database development, one I suspect many would enjoy more than the typical relational database classes taught today.

Mr. Celko has again delivered an essential text on SQL, and it would serve as a springboard for a thorough introduction to all things data.

Fred
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


22 of 23 people found the following review helpful
4.0 out of 5 stars A very valuable SQL-style guide, August 30, 2005
This review is from: Joe Celko's SQL Programming Style (The Morgan Kaufmann Series in Data Management Systems) (Paperback)
This is not the first book I have read from Joe Celko. I appreciate very much his clear and concise style and the examples he provides, always meaningful and to the point. This book is not the exception and it completely fulfilled my expectations. In a very scholarly way (rule / rationale / examples / exceptions) Mr. Celko covers all the aspects that I could expect from a "programming style" book: layout, naming, SQL do's and don'ts, guidelines about views, triggers, stored-procedures, checks on columns, etc. He also provides a list of resources regarding standards (Military, ANSI, ISO, Industry) that I found very useful. I can highly recommend this book to any experienced or inexperienced person that deals with SQL (developer, DBA or even a data modeler)

My only criticism would be regarding a few unkind remarks he wrote about "newbies". I do not deny the value of showing examples of bad SQL coding followed by a better way of doing it, but there are ways to present them. I wouldn't be happy to see my name in a sentence like "As an example of a horrible misuse of SQL, [name of the guilty] posted a procedure ...".

It was also not very nice the way in which Mr. Celko introduced the Basic Software Engineering section: "With some embarrassment, I will now give what should have been covered in a freshman course". If a "newbie" is reading this book to gain some knowledge, he or she doesn't deserve the criticism. They know they are inexperienced and they are trying to improve. And the sloppy programmers, who may deserve such a criticism, they are not going to read a book like this anyway. Don't you think?
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


12 of 12 people found the following review helpful
3.0 out of 5 stars 3.5 stars: Has good stuff but very undercooked, March 26, 2007
This review is from: Joe Celko's SQL Programming Style (The Morgan Kaufmann Series in Data Management Systems) (Paperback)
I'll expand on that when I have time; but for now, real quick:
PROs:

- As usual for Celko's books, you get this feeling of conversing with a knowledgeable and overall very likeable individual with a good sense of humour (he got me laughing on page 2, see his comments on the making of fine furniture).

- Good justifications are given for many rules of thumb that, as of now, you're likely to be adhering to on faith.

- A number of unobvious, sharp, mind-stretching tidbits (an ever-present feature of Celko books).

- Very good bibliography. Celko is not a "narrow specialist": reading pointers he gives are varied and very interesting. Also, links to a lot of net material. Great.

- He writes simply.

-----------------------

CONTRA, the one and only problem: the book appears to be written in a terrible hurry, which is manifested by the following occurrences (not exhaustively):

- Sometimes the author has something to say, but does not say it intelligibly (e.g., section 1.2.7)

- Sometimes he doesn't have anything to say, but gibbers on anyway (e.g., section 3.15)

- Sometimes he belabours the obvious or maybe even spurious: for example, there's too much of this "unlearn OO to understand SQL". One doesn't need to unlearn what one knows to learn something he doesn't; there's no clear-cut distinction: for example, operating on STL collections is very set-like, quite SQL'ish actually: you provide a predicate and it's then applied internally in a set-scoped operation. Matlab is very similar. BLAS is very similar. Fortran is similar. Iow, thinking in sets is an important thing to point to -- once; but after that it's beating a dead horse; move on already. Especially since it isn't really as black-and-white as the author suggests.

(4) The book is very inadequately indexed: index is very small; nothing can be found. What's SQL/PSM? I don't think it's been defined anywhere, but perhaps I missed it; off to index I go... and find nothing there. How nice. I mean, come on -- a five-page index in a technical book?

(5) Dropping French. Is it really necessary? "Sistemé International d'units", OK.

There's more stuff to talk about, both good and bad; but I've no time to write it up right now. So, finally: is it a worthy book?

Well, the book is flawed but not useless by any means. It's not a must read, but if you got a few discretionary bucks and a bit of free time, it's worth reading. I've learned a few interesting things here; ~1/3rd of the reading has been pleasant: in addition to knowing a lot of stuff, DB-related and beyond, Celko's got a real good sense of humour and a gift of gab. Were this book a brochure one-third its current size sold for five bucks, I'd give it five stars. OK, ten bucks.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


11 of 11 people found the following review helpful
5.0 out of 5 stars Excellent book in excellent style, April 15, 2006
By 
dalepres "dalepres" (Park Hill, OK United States) - See all my reviews
Verified Purchase(What's this?)
This review is from: Joe Celko's SQL Programming Style (The Morgan Kaufmann Series in Data Management Systems) (Paperback)
Too many database books are written by developers whose expertise is OOP and not SQL. While I don't agree with Mr. Celko on every point, keep in mind that he was on the SQL Standards Committee for 10 years. Even if you don't agree with him on every point, his level of expertise is undeniable - unless, perhaps, the questioner can provide evidence of greater knowledge and expertise.

This book is to SQL grammar and style as "The Elements of Style" by Strunk and White are to English grammar and style. Mr. Celko explains, in terms that should be easily understood, why SQL should be written in standard SQL while still allowing that there can be exceptions just as verbal communications, in any language, should follow the standard grammar of the language unless there is good reason to slip into a localized dialect.

Where one reviewer rated the book with 1 star because that reviewer disagrees with Mr. Celko on a single point of database design, his antagonistic remarks have nothing to do with the point or the value of this book.

As the editorial review states, this book is not for beginners. If you have been programming SQL for a year or more and you want to fine tune the quality of your work, this work is something you should surely read.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


8 of 8 people found the following review helpful
4.0 out of 5 stars This is the nth try to post this review, November 24, 2006
By 
Verified Purchase(What's this?)
This review is from: Joe Celko's SQL Programming Style (The Morgan Kaufmann Series in Data Management Systems) (Paperback)
If this review finally goes in, I shall be pleased but surprised, There is something wrong with Amazon's linking. I have spoken to support and they don't know what it is. Anyway...

This is a mixed bag, but mostly very good. Lots of excellent information about different versions of SQL vs. standards, and fascinating excursions into the underpinnings of coding systems, measurements, scales, ratios, etc. We should all be a lot more aware of the work that has been done and codified in many international standards. Apart from anything else, it would save people from re-inventing so many wheels - and making some of them square!

There is an excellent and much-needed stress on the need to use relational thinking when you are working in the SQL environment, with the focus on natural keys and set-oriented processing. He rightly decries the use of "external locator" keys (which most of us call "surrogate" keys, though he defines that term differently) - anyway, basically the "Identity" type. He is perhaps a little too extreme in pretty much absolutely outlawing them, but I agree with the general principle. They are an expedient pushed by people who don't understand relational design. Natural keys are much better. (But I have to agree with another reviewer that the SSN is problematic. Coming to the US from Canada, I couldn't believe the SSN was not a check-digited number, unlike the Canadian SIN, or any credit card number, or banking ABA's. I guess the age of the system was one issue. But the result, anyway, is that duplicate SSNs exist and that they are frequently invented or stolen.)

As a self-described "old fart" he castigates the design errors that may be committed by those (like me!) who grew up in the age of punched cards and magnetic tape. But surely few current database designers have ever seen a punched card, and rarely encounter a good old sequential fixed-length-record file, let alone a mag tape. The model that leads them astray these days is not the sequential file, but the Excel spreadsheet! Time and again I see HORRIBLE designs, violating all the normal forms from 1 to 3 and beyond, based on the columns of an Excel spreadsheet. Another factor is the lack of relational training - how many people have read Codd or Date? and the harm done by the early PC databases that were just a kind of disorganized dumping-ground for data, draining meaning from the term "database."

Some of his mandates are perhaps a little too absolute "Don't use cursors" - well, 99% of the time, very true. You should be thinking sets, not serial access. But there are a few occasions where a cursor can be a useful weapon in your armory and can even execute faster than a set manipulation. Not many, but a few - beyond the outlying cases he describes. Similarly with triggers - yes, generally DRI is far preferable (if your DBMS supports it). But if you want customized transaction audit capture, triggers are the natural way to go.

A few beefs:

There's a sprinkling of typos, and I did spot one actual error: on p 114, he presents "WHERE a = b + 2" as the alternative to "WHERE a + 2 = b - 4." Oops! Obviously the valid alternative is "WHERE a = b - 6."

The discussion of Camel Case is too limited: there are a lot of variations and his definition is at odds with the widely used Microsoft definition, which would have been worth mentioning. For MS, camel case is like "thisCase" and Celko's camel case, "ThisCase," is called Pascal case.

I found his advice on formatting and display of code sometimes odd. Often when he showed example A and then "see how example B is more readable " - I thought example A was clearer! He refers to studies on visual perception, eye movement, etc., but I am not sure that such studies done in the context of reading normal prose are valid for SQL, or other programming-type text. Comprehension likely occurs in different stages or chunks.

Also, surely Hungarian notation is found in strongly-typed, not weakly-typed, languages. In a weakly-typed language like REXX, a variable can be a string one minute, an integer the next. What prefix can you use? Whereas in VB, for instance, up to version 6, MS recommended prefixes to remind the programmer of the fixed type as defined, so he would not be tempted to write "intAccountID = "New Customer" or suchlike.[...]

Summary? Well, OK, I've listed a few problems, but overall, get this and study it - there's lots of fascinating and rewarding material, from someone who has been working in this field a long time and has gone very deeply into many aspects of it. Many of the SQL examples will really stretch your brain - his other books do that too!
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1 of 1 people found the following review helpful
3.0 out of 5 stars Good information but arrogant writer, September 29, 2011
This review is from: Joe Celko's SQL Programming Style (The Morgan Kaufmann Series in Data Management Systems) (Paperback)
This book has some truly excellent information and I recommend it to anyone working with a RDBMS. It is definitely much more than just a style guide. Unfortunately, the writer too often lapses into condescension and sometimes fails to anticipate and address easy criticism of his assertions.

It is terrific to see some chapters devoted to calling out common errors in database querying. Celko continually hammers home the point that RDBMS are optimized and built for set-based operations. This is an extremely important concept that cannot be overemphasized. This is why there is so much poorly written SQL code in production with such common issues as misuse of temporary tables, cursors, and looping. Celko does a good job of pointing this out and offering alternatives to some of these very common problems. The book is worthwhile for these chapters alone.

Celko also makes interesting arguments about data modeling and what he perceives as common mistakes. His vehement argument against the use of identity (auto-number) fields as primary keys in tables is interesting and something I partially agree with, but he tries to back it up by saying this inevitably leads to a data model with no integrity without even mentioning the common workaround of using check constraints. He also fails to address the reason why data modelers often use auto-numbers in the first place - to make it easier to join tables together.

Oddly enough, I find his purely "style" based chapter on readability of SQL code to be among the weakest. As someone else pointed out, his examples of what is more readable actually seem opposite. And his citation of sources seems dubious since they are old studies about reading (presumably books, articles, etc.) versus reading code specifically. Celko would probably have been better served in emphasizing consistency of style over a very specific style.

Which leads me to my biggest problem with this book: Celko can be rather cruel. While it is important for a book like this to point out common mistakes and why/how to avoid them, Celko actually names names. There are several instances where he gives examples of bad SQL from postings on newsgroups by what he sneeringly calls "newbies" and actually lists the full name of the person who posted it! This is completely unnecessary and distasteful and makes him seem more like a bully than an authority.

If you can overlook the arrogance of the writer, this book contains some truly excellent information.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1 of 1 people found the following review helpful
4.0 out of 5 stars Great book., July 13, 2011
By 
John S. Kret "EaglesFan" (berwyn, il United States) - See all my reviews
(REAL NAME)   
Verified Purchase(What's this?)
This review is from: Joe Celko's SQL Programming Style (The Morgan Kaufmann Series in Data Management Systems) (Paperback)
This is a great book to get you on the path to better coding. I didn't always agree with all the points but overall there ae many good tips in the book.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 3 people found the following review helpful
4.0 out of 5 stars I really enjoyed this book, August 16, 2006
By 
Adam Machanic "Data Dude" (Melrose, MA United States) - See all my reviews
(REAL NAME)   
This review is from: Joe Celko's SQL Programming Style (The Morgan Kaufmann Series in Data Management Systems) (Paperback)
Wading through badly written SQL is a nightmare on the best of days. Proper--and consistent--attention to capitalization, indentation, and other formatting standards makes SQL much more readable and therefore maintainable. The standards outlined in this book are for the most part very well thought-out, and a great starting point for creating a set of enterprise SQL development standards. If more SQL developers would read this book, I would have many less headaches in my day-to-day work, so I believe this is a valuable purchase.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


3.0 out of 5 stars If you like Joe's other books, you'll probably like this one, September 15, 2013
Verified Purchase(What's this?)
This review is from: Joe Celko's SQL Programming Style (The Morgan Kaufmann Series in Data Management Systems) (Paperback)
I didn't agree with all of his recommendations, but I didn't really expect to. Not a bad guide for writing readable SQL,
but you might get just as much by hanging out on Stack Overflow in the DBA pages. It has a lot of nicely-formatted
and well-explained code.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


0 of 1 people found the following review helpful
5.0 out of 5 stars Great SQL Style Reference, August 30, 2006
This review is from: Joe Celko's SQL Programming Style (The Morgan Kaufmann Series in Data Management Systems) (Paperback)
This is a great reference for how to write clear, concise, and efficient SQL. If you are looking for good ideas for SQL coding standards, you will find them here.

In my career, I've seen a lot of poorly written, nearly incomprensible SQL, which is always harder to maintain. I just wish more novice SQL developers and DBAs had read this book.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


‹ Previous | 1 2 | Next ›
Most Helpful First | Newest First

Details

Joe Celko's SQL Programming Style (The Morgan Kaufmann Series in Data Management Systems)
$45.95 $33.24
In Stock
Add to cart Add to wishlist
Search these reviews only
Send us feedback How can we make Amazon Customer Reviews better for you? Let us know here.