This book sheds light on the principles behind the relational model, which is fundamental to all database-backed applications--and, consequently, most of the work that goes on in the computing world today. Database in Depth: The Relational Model for Practitioners goes beyond the hype and gets to the heart of how relational databases actually work.Ideal for experienced database developers and designers, this concise guide gives you a clear view of the technology--a view that's not influenced by any vendor or product. Featuring an extensive set of exercises, it will help you:
understand why and how the relational model is still directly relevant to modern database technology (and will remain so for the foreseeable future)
see why and how the SQL standard is seriously deficient
use the best current theoretical knowledge in the design of their databases and database applications
make informed decisions in their daily database professional activities
Database in Depth will appeal not only to database developers and designers, but also to a diverse field of professionals and academics, including database administrators (DBAs), information modelers, database consultants, and more. Virtually everyone who deals with relational databases should have at least a passing understanding of the fundamentals of working with relational models.Author C.J. Date has been involved with the relational model from its earliest days. An exceptionally clear-thinking writer, Date lays out principle and theory in a manner that is easily understood. Few others can speak as authoritatively the topic of relational databases as Date can.
Chapter One Introduction
A Remark on Terminology
Principles, Not Products
A Review of the Original Model
Model Versus Implementation
Properties of Relations
Relations Versus Relvars
Values Versus Variables
Chapter Two Relations Versus Types
Data Value Atomicity
So What's a Type?
Scalar Versus Nonscalar Types
Chapter Three Tuples and Relations
What's a Tuple?
Some Important Consequences
What's a Relation?
Further Important Consequences
Why Duplicate Tuples Are Prohibited
Why Nulls Are Prohibited
TABLE_DUM and TABLE_DEE
Chapter Four Relation Variables
Updating Is Set-at-a-Time
More on Candidate Keys
More on Foreign Keys
More on Views
Relvars and Predicates
More on Relations Versus Types
Chapter Five Relational Algebra
More on Closure
The Original Operators
Evaluating SQL Expressions
Extend and Summarize
Group and Ungroup
More on Relational Assignment
The ORDER BY Operator
Chapter Six Integrity Constraints
Why Database Constraint Checking Must Be Immediate
But Doesn't Some Checking Have to Be Deferred?
Constraints and Predicates
Chapter Seven Database Design Theory
The Place of Design Theory
Functional Dependencies and Boyce/Codd Normal Form
C. J. Date is an independent author, lecturer, researcher, and consultant specializing in relational database systems. He was one of the first persons anywhere to recognize the fundamental importance of Codd's pioneering work on the relational model. He was also involved in technical planning for the IBM products SQL/DS and DB2 at the IBM Santa Teresa Laboratory in San Jose, California. He is best known for his books, in particular An Introduction to Database Systems, Eighth Edition (Addison-Wesley, 2004), the standard text in the field, which has sold nearly three quarters of a million copies worldwide, and (with Hugh Darwen and Nikos A. Lorentzos) Temporal Data and the RelationalModel (Morgan Kaufmann, 2003). He enjoys a reputation that is second to none for his ability to explain complex technical material in a clear and understandable fashion.Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects.Genevieve d'Entremont was the production editor and copyeditor for Database in Depth. Matt Hutchinson proofread the book. Adam Witwer and Colleen Gorman provided quality control. Lydia Onofrei provided production assistance. Reg Aubry wrote the index.Michele Wetherbee is the creative director for the Theory in Practice book series.MendeDesign designed the cover of this book. Karen Montgomery produced the cover layout with Adobe InDesign CS using the Akzidenz Grotesk and Orator fonts.Marcia Friedman designed the interior layout. Melanie Wang designed the template. This book was converted by Keith Fahlgren and Andrew Savakis to FrameMaker 5.5.6 with a format conversion tool created by Erik Ray, Jason McIntosh, Neil Walls, and Mike Sierra that uses Perl and XML technologies. The text font is Adobe's Meridien; the heading font is ITC Bailey; and the code font is LucasFont's TheSans Mono Condensed. The illustrations that appear in the book were produced byRobert Romano, Jessamyn Read, and Lesley Borash using Macromedia FreeHand MX and Adobe Photoshop CS.
Do not get me wrong. I do enjoy understanding the robust theory behind the Relational Model. But I am on my way of finishing this book and I still do not see how these compiled chapters of excessively-abstract theory will help me as a practitioner because: * The author insists with Tutorial-D on his examples. In practical terms this has little or no value. * So many concepts are irrelevant in practice, i.e. what is the point in dedicating a whole chapter to types and domains, and explaining why they are the same? Relations and Types: What piece of this chapter can be exactly useful for my day to day tasks? * It constantly mixes concepts between model and implementation and does not provide a good guidance on separating those two worlds.
I can understand if the author resents the ANSI SQL and he would like to explain the details. But that is a topic for non-practitioners and theory analysts. I was actually expecting a book with common examples, and how to adjust typical situations to a good relational theory (and mentioning its benefits) using the technologies available in the market. After all, I think that is the concept of being "practical". So, do not be fooled by the subtitle of this book.
Bottom Line No, I would not recommend this to a friend
To be fair, when I started reading the book I was looking for a mathematical coverage of realtional algebra and other math that underlies all relational database models including Oracle and SQL Server. I was seeking the common priciples that unite these systems. The book does cover relational theory but I did not find it to be organized from the mathematical point of view. Rather than building database theory from the math, the book seemed to attempt to overlay modern databases on top of the algebra.
In my twenty years in the field of data analysis I have watched many organizations fail in their implementation of relational data systems. The successes I have witnessed were the products of information analysts and database designers who understood the relational model.
This is the most (and perhaps the only) readable book on the subject of the Relational Model which is addressed to real-world practitioners. It will clarify your thinking.
If you never write SQL code, you don't need this book. Otherwise, you probably do.
An excellent introduction to the relational model by one of the best thinkers in the field.
By Dan Hanks
Comments about oreilly Database in Depth:
When I was early in my Computer Science degree I took a course in which we discussed database fundamentals. In that class we learned about things like tuples, relations, predicates, predicate logic and deductive proofs. All of these were involved with the relational model, but it wasn't until later when I discovered the writings of Fabian Pascal and C. J. Date that I began to really understand how the above concepts tied into the database systems I was using, such as Oracle, MySQL, and Postgresql. One of those aha moments came when I realized that the deductive proofs we had done in that class were essentially queries to a database system. I came to see how each row (tuple) in a database table (relation) represented a set of values for a predicate that the relation represented. Overall, a database, then, was the logical AND of all the facts represented by the tuples of each relation. Queries were simply deductive proofs which allowed one to derive new facts from existing facts in the database. Good stuff all around.
If you're lucky, you will have studied Date's venerable Introduction to database systems while taking a college course in databases. If not, then you're still lucky, becuase Date has condensed the fundamentals of the relational model into a very approachable and very practical book published by O'Reilly, Database In Depth
Database In Depth takes you through a tour of the key concepts of the relational model, starting with the very basics (types, tuples, relations and so forth), and takes you step-by-step into more formiddable territory (stuff like normalization, join dependencies, integrity constraints, relational algebra, and the like). Throughout the book, Date explains each concept in his characteristic clarity. Date knows this stuff through and through, and it shows.
You may be tempted to think like many others that theory and fundamentals are fine and dandy, but how practical are they in the real world? In my experience, they're crucial. By understanding the fundamentals and the theory behind the databases you work with, you can avoid costly design flaws that lead to poor data integrity. By understanding these concepts, you can design databases that you can trust absolutely to store and deliver accurate results. I've had to work with databases that weren't designed with these concepts in mind, and the difference is stark.
One warning, you wont be spoon-fed here. The material can be challenging, and Date expects you to use your brain. This isn't SQL For Dummies. The real advantage you will gain by reading a book like this is that you will understand the mathematical and logical reasoning behind practical design principles such as why, for example, it's important to normalize (and the pitfalls you can run into when you de-normalize), why nulls can potentially lead to bad logic, and why duplicate rows are a bad idea all around. You'll be able to understand the ways in which most of today's database systems fail to faithfully implement the relational model, and the consequences of those failures (and consequently how to design your databases well despite these shortcomings).
Unlike many computer books that become obsolete within a year or two of their publication, Database in Depth is among that narrow collection of computer books that remain useful and relevant for years. This is precisely because it remains grounded in theory and fundamentals, instead of being tied to specific brands and versions of software.The bottom line here is if you do much of anything with databases, then just about anything you read by C. J. Date will be worth your while. Database In Depth is no exception.
Whilst the author is obviously an expert with a detailed knowledge of the relational model and its problems, he is an awful writer, so it takes a lot of work from the reader to extract information from this book. The book is peppered with unnecessary phrases like "At this point I would like to recap on some of the points I have made in this chapter, whilst paying special attention to blah blah blah". Just make the point!
I've always found O'Reilly books to be admirably concise, so I was really disappointed to find a book so in need of radical editing on their shelves.
The author also uses the book to attack other authors and database professionals, even at times the original reviewers of the book. It gives that uncomfortable feeling of walking in on a private argument.
Excellent, concise, challenging, and thought-provoking
Comments about oreilly Database in Depth:
Since I read Date's An Introduction To Database Systems 8th Edition, all 1024 pages of it, I've been wishing he'd do a shorter guide so that people put off by the size of Intro (outstanding though the book is) would still benefit from learning the relational model.
Database In Depth is even better than I expected, since he incorporated concepts from Third Manifesto as well.
This is a book every software developer should read. The relational model offers a useful, elegant, and complete model of data that everyone using SQL, XML, or any other data management technology needs to understand, if only to use their own technologies more effectively.
Well-written, well-organized, and the examples at the end of the chapters are truly icing on the cake - they provoke thinking, not just rote memorization. This will make an excellent class textbook.
This title offers brief descriptions and careful defintions of all the features of the relational model -- and illuminating discussions of those features which seem to be most frequently misunderstood, ignored, or forgotten by so-called database practitioners.
For those not familiar with C. J. Date, let me offer this: he is a profound and prolific contributor in the field of data, databases, database systems, and the languages used therein. His thoughts and ideas have always been carefully considered and captured in well written, painstakingly correct but nontheless entirely readable prose.
This book is a much smaller tome than Date's "Database Systems" -- detailed and formal explanations will have to be found elsewhere. This book doesn't touch upon the topics covered in Date's (and others) "Temporal Data" -- the scope is strictly limited to the relational model.
There is very little new in this book - I detected only a few slightly different descriptions of things I've read (and heard - lucky me!) from Date over the past few years. But the material which is included is well organized and very polished.
As Date points out, our understanding of the relational model is maturing. More exciting to me is that, in recent years, our ability to describe the relational model seems to be improving more than our ability to understand it. This is due in large part to Date's efforts.
I'm completely glad to have this small volume in hand. If you embrace the relational model and are a practitioner, you will be, too.