Customer Reviews

SQL and Relational Theory: How to Write Accurate SQL Code

5 star:		(7)
4 star:		(4)
3 star:		(2)
2 star:		(0)
1 star:		(0)

 

 

In this book the author argues that the only database model that will endure is the relational model, because it is "rock solid" and "right." Other models such as the "hierarchic model" or the "object oriented model" or the "semistructured model" are doomed to fail because there is no consensus on what they actually represent.

The relational model of databases is based on the pioneering work of E.F. Codd, a mathematician working for IBM who published his initial seminal paper in 1969. A language to support queries in relational databases was subsequently developed, which was ultimately named SQL, and variants of that language are used to extract data from relational databases.

This book gives an excellent review of SQL; it includes many examples of SQL code. The book is written as a technical treatise and would not be an easy read for someone who isn't familiar with the use of SQL. The original description of relational databases was mathematical in nature, and this book follows in that vein, using mathematical "proofs" to illustrate the best approach to the use of SQL in relational databases. There are many exercises given at the end of each chapter, and the answers to the exercises are given at the end of the book. There is a seven page index. Appendices A & B provide a somewhat simplified, easier to read discussion of the primary goals of the book than the book chapters do, for those wishing a simplified synopsis of the main points, I'd suggest reading those appendices first.

For those who would appreciate a theoretical discussion of database design and SQL development that will "bullet proof" their code, this is an excellent book. For those who'd like a more nuanced discussion of why there should only be one instance of any data set in their tables, this book provides the answers. But for the mathematically challenged, it may be tough going.

I have spent the last three or four weeks struggling through this book. Never content to know only the "how" of something, I wanted to learn some of the "why" behind SQL databases. This book covers that in depth, with a steep learning curve for someone like me who has a bit of experience using SQL in various applications, but who has never formally studied it. That is not a bad thing.

First, a bit of background. The author, C. J. Date, is well known in the field for his classic textbook An Introduction to Database Systems, which has gone through at least eight editions. He began working on databases in 1970 at IBM and worked with the inventor of the relational theory of database design, E. F. Codd. There is no doubt that this is a man who knows what he is talking about.

What this book sets out to do, in about 400 pages, is describe and define the relational model in greater depth and compare how SQL is currently used in many database applications like Oracle and MySQL to the theoretical ideal. As he does this, Date points out several inconsistencies with the SQL adaptation of the relational model and makes suggestions for how to adjust common usage to more closely conform to the ideal while acknowledging that at times perfect syncronization will be impossible using SQL. He also gives numerous examples of how it could be done in Tutorial D, which is an interesting study in itself.

I submit that this book is ideal for theorists, for highly qualified and experienced database administrators who want to learn at the feet of a sometimes emphatic and slightly dogmatic master who has been instrumental in the creation and spread of the relational database idea, but whose theory has not been perfectly implemented. If you merely want to know how to work within current implementation constraints without the larger picture, skip this book. If you want some fascinating, and sometimes difficult to grasp background and theory that will likely make you a better database wizard, this book is likely to help you get there.

Here are some highlights, sample questions and topics discussed in the book:

* What are the differences between the relational model and the various product implementations available today and in the past?
* Should a relational database allow duplicate entries?
* Why are null values a bad idea?
* What do relational expressions mean?
* Why must database constraint checking be immediate, at least in theory, and why is it often deferred in practice?

Seriously, that is just the beginning. There are excellent examples of SQL code throughout the book, great discussions of the mathematics behind the genesis of relational theory, and more. Beware, though, you may have to work to understand it, but it will be worthwhile for those who do.

C. J. Date has just released what I would say is the "Code Complete" manual for SQL. Not for the layman, this work explains [in intricate detail] the whys and wherefores of SQL, and how to over its many idiosyncrasies. From Keys and Constraints, to using joins, to all the types of normalization, this is a great reference for everyone.

If you read this book, please follow the author's instructions and don't skip over sections because of some familiarity. The detail in which he delves into even "simple" functionality in SQL are useful to see the big picture.

First, disclaimer: this book is not for everyone. If you are beginner in database programming and SQL, there are plenty of other books to read. This book is more for seasoned software developers with years of practice in the field, who, like me, never really worked on database level before. There are some facts left forgotten since university years that can really make the difference on how do you see your task. Quoting from the book - 'Logical difference is a big difference'. If you want to refresh your knowledge of the theory behind the SQL, this book is for you.
Author covers surprising amount of area in just a 400-page book (this count includes answers to all exercises, by the way). Author starts with basics - types, domains, tuples and relations - and immediately shows how these abstracts relate to their SQL counterparts. After you learned why nulls are bad (but sometimes necessary) and why you shouldn't use row ids in your SQL code, we gradually get to the power of formal logic behind relational algebra - and again, there's a comparison on how it looks like in SQL.

What I really liked in author's style is that he is not afraid to repeat important things until they really settle in your head. For eternally multitasking people this is a huge bonus.

The culmination of the book is the chapter 'Using logic to formulate SQL expressions'. While short, this chapter is really important and I recommend reading it several times and doing all included exercises. Again, it's not about coding, it's about proper thinking. If you know strength and weaknesses of SQL compared to relational theory, you can apply you skills more effectively.

And the last dish is an appendix B, 'Database design theory'. If you forgot why the table(s) should be normalized (and HOW they should be normalized), this is a good text to refresh your knowledge.

As I told earlier, this book is not for everyone. You should already know SQL (not all of it, but at least the basics) and have some database experience behind you. Remember, designing bad database is frustratingly easy. Read this book, get better.

NOTE TO COMPARISON SHOPPERS:
The author himself (as stated in the Preface) intends for this book to REPLACE his earlier "Database in Depth" book. You need not buy both. Just buy THIS one.

I would give this book extra stars if I could!

This book has everything I could ask for:

>> the author has *deep* expertise on the topic,

>> the book *will* give you new insights on the topic,

>> the book is mostly self-contained
(meaning you aren't expected to have a particular training or math background -- all necessary fundamentals are covered in the book when they are needed).

You might think my three-bullet list (above) seems small and underwhelming. If so, then stop for a moment and try to remember the last time you read a technical book that really achieved perfection on all three points. (Then go write a raving review of THAT book, because it surely deserves it.)

I am usually happy with a book as long as it teaches me even ONE new idea that I think I'll carry with me throughout my career. This book has provided me with handfuls of insight that will certainly influence (and ease) my work for years to come. Furthermore, most of these insights are applicable far beyond the DBMS realm.

I highly recommend this book to anyone with a strong interest in SQL. Additionally, I wish I could *force* all DBMS *implementers* to read this book! That isn't to say that this book highlights ideas that aren't yet implemented -- that isn't true at all. I want implementers to read the book because they might enjoy their work more after reading this book, and I think they might be inspired to think more creatively about how to implement (and/or reimplement) parts of their DBMS, since this book highlights several ways that implementations are actually given much more freedom in implementing the relational model than perhaps has been taken advantage of.

I love this book. For 30 dollars it is a bargain. Buy it!

NOW FOR MY ONE CRITICISM:

I had to force myself to remain patient and good-natured as I read the first chapter, and certain parts of the first three chapters. Why? Answer: because the author is sometimes excessively wordy, and it seemed to me that we were "beating around the bush" for several paragraphs before just STATING SOME POINT OUTRIGHT. Sadly, (apologies for the cruelty), the word "windbag" crossed my mind more than once. HOWEVER! HOWEVER! It would have been too hasty of me to throw down the book in disgust at such an early point in my reading. And I am very, very glad that I did not. As you can tell by the maximum star rating that I chose -- and by everything I said above -- I love this book and am thrilled to have read (and re-read) it. Just beware that the author's verbose style might take some getting used to.

Keep the following in mind, as well: all the "extra wordiness" that initially annoyed me was later converted into a great asset in subsequent chapters that covered deeper and deeper material.

Criticism Conclusion:
It turns out that wordiness is in the eye of the beholder, and once I (the beholder) found myself in UNFAMILIAR topics, the wordiness was suddenly a thing of grace that eased me into the topic.

To start, this book is about theory and is not for anyone looking for a specific vendor implementation. Just trying to get through the first few chapter is tough because it's (just as the rest of the book) very dry and full of theory. There isn't much practicality in this book that you can apply to the real world but it does give you a way to think about what is going on behind the SQL scenes - or does it? Since each vendor has their own interpretations and implementations, I'm not so sure how this book can help structure better SQL statements in practice.

Since this book is nothing more than a history lesson with insightful explanations and examples, I would only recommend it for the academics. The book itself is not all bad however; I enjoyed chapter 4, "No duplicates, no nulls". The truth tables presented really give an idea of what potential bugs you might run into while dealing with comparisons.

To sum it up, this might as well be a textbook.

This book doesn't cover any specific database and it doesn't teach SQL. Instead what this book does is to examine the relational data model and looks at what parts of SQL do and don't support that model. The book deals almost exclusively with what parts of SQL to use in order to properly define and use a relational database. Many people are probably wondering what the point of this book is because they believe that a database created using any of the Database Management Systems (DBMS) that support SQL are relational databases and the point of this book is to clearly demonstrate that many such databases are in fact not relational databases at all.

One issue that the book deals with all the way through is terminology and how most books dealing with databases use the same term to refer to two or more different things which in some cases lead to confusion since the subtle difference can be extremely important to understanding relational databases properly. For example a diagram showing a database 'table' may show the 'columns' and 'rows' in a particular order whereas a 'relationship' in the relational model does not imply any particular ordering to the 'attributes' and 'tuples' it contains. By clearly defining terms when they are first used (or soon after) this book makes it extremely clear just how the real relational model differs from many people's conception of it.

While the book deals throughout with relational theory (as is obvious from the title), it deals with it in a very practical way showing you how to apply it so as to get the greatest benefit from its use - logically consistent databases. Anyone who is developing databases or writing programs that access databases and who has at least a basic knowledge of SQL will get some benefit out of this book, particularly those who already consider themselves to be at an intermediate to advanced level (since beginners may not have a sufficient understanding of databases to be able to follow the discussions). This would not be the first book on databases that you'd add to your library and probably not the second but it might be the third or fourth.

Well, lots. He is a true believer, but what the hell, when he writes on anything relational, he is fascinating.

Theory Behind Practical

I have been a SQL guy for a long time especially specializing in writing better sql code. This notion was with me until I read this book. However, after reading this book, I felt that so many things I was missing behind my working on SQL. The book well covers the theory behind relational database management. I have read few books of the same author who can be arguably called as one of the pioneers in Relational Theory in database management. Anytime, I ventured to read any of books authored by him, I get fascinated by his way of explaining the SQL in relation to mathematics, set theory etc.

Initially, while reading the book I struggled to concentrate and relate the information to my daily working on SQL. The book really related the theory behind of working of various concepts in SQL such as constraints, views, operators, joins etc. The author has particularly stressed upon the reason behind various theories in SQL in various database platforms.

I was impressed on the topic on using logic to formulate sql expressions. It opens up the idea in readers mind on how to approach to a sql deduction.

I suggest this book to all the database professionals who want to know the why's of database theories. Trust me, it really helps and you will be amazed to know how much more you will know on SQL.

SQL and Relational Theory How to Write Accurate SQL Code
C.J. Date / O'REILLY
This is the best SQL book I have read so far! I have read many SQL books but this one beats every single one of them. This book is about how you can apply relational theory directly to your use of SQL. My favorite chapter was chapter 1 it teaches SQL terminology. It talks about The Relational Model, Principles, Structural Features and many more. Another good chapter is chapter 11 where it shows how to formulate logic. This book is great if you want to learn SQL and its logic, I have read this book twice. After using SQL Server for many years this book opened up my eyes to some of the struggles I have come across, I have learned to use SQL logic wisely. I am ready to go out into the real world I felt I was trapped inside a box and there was no other way to do things in sql, I thought my way was the best way. But after reading and talking with some people I realized I am not the only one using sql there are many ways of writing sql to do the same thing but better performance and now that I met a few sql people I felt small because they are way smarter than me when it comes to sql. I recommend this book!