Database in Depth: Relational Theory for Practitioners by C.J. Date

Database in Depth: Relational Theory for Practitioners

  • Author: C.J. Date
  • Softcover: 208 pages
  • Publisher: O’Reilly(May 1 2005 12:00AM)
  • Book dimensions: 9.1 x 7.0 x 0.7 inches
  • ISBN: 0596100124
  • ITBookworm score: 0.5 /5

Score Reasoning

This book has every element I like in a book; theory, personality, strong advice, and chapter exercises. It’s also a book that most DBAs will grow into.


This is one of the best database theory books I’ve ever read. I think that far too many DBAs memorize rules and never really bother to understand the theory behind them, and it’s practically impossible to really know how to use those rules if you don’t understand the reasoning for them. This book is quite platform independent so it works for any DB platform out there. The discussions are concise with lots of examples. At times there are some very scientific discussions that you’ll have a hard time understanding, but that’s the mark of a good book. If you fully understand everything you read the first time then there’s no value in keeping it around after your finished. I always prefer books that offer me some sort of growth. This is one of those books that you can grow into. You may not understand everything now, but as you read it more and more you’ll slowly start to get some of the finer points. One of the things I like about this book too, is all of the exercises at the end of each chapter. There certainly are enough of them. I thought I was doing fine in my reading most of the time, but when I got to the exercises I found that I hadn’t absorbed as much of the material as I thought. On many occasions I had to go back and actually study the material to finish the exercises. You really can’t get much more of an authority on the topic either. Date was around in the beginning when Codd was developing the theory. He was there, and many of his arguments are solid and to the point. Even if you don’t agree with everything he says, you should at least hear his points and know both sides of the debate. It’s really an excellent book, and I look forward to reading it again next year to see how I understand things better. The one thing I didn’t really like is his continual use of the Tutorial D language. It’s not relevant to any of the DBs we work with, so I really don’t care to see examples written in it. I found myself kind of just skimming over those examples most of the time. However, the SQL examples I studied intently. He explains his reasons for using it, but that still doesn’t make it relevant to me.

Who is this book really for?

Anyone responsible for modeling or supporting databases to pretty much any degree should know this kind of generic theory. That said, it isn’t for the novice or the faint of heart. You won’t get very far in modeling if you try to learn modeling from this book because that’s not what it’s for. If you’re an experienced modeler and have been working with normal forms and the problems involved in implementing them, then you’ll be better prepared for what this book has to offer. I can’t say this enough though… if you’re a beginner you’ll be almost completely lost in this book.

Writing Style

I saw a review on Amazon where the guy complained that the writing style was too convoluted . He said that the sentences were arranged in such a way that they went off on tangents, and were very hard to follow. I could see how he would think that… it’s called good grammar. This book is expertly written. Date has a very relaxed style that not only explains his point very well, it doesn’t condescend. It’s very easy to tell that he’s an educated and experienced speaker, and his writing reflects that he’s comfortable with himself. I know that’s a funny way to put it, but I could actually imagine that he was talking directly to me. It was refreshing to see someone’s personal style come out in their writing for a change. Too many publishers completely trample the author’s voice and it makes for very dry reading. I loved the style of this book. The points are explained well, and they’re well thought-out. If you read it a little slower than you would most books, more in the style of someone speaking, then you’ll really find the meter and the structure work.


For the most part this is a solid book. I’ve abused it pretty well and it’s holding up pretty well. The only complaint I really have is the cover is coming off of the spine. Whenever I fold the book backwards, the cover completely separates. Fortunately it doesn’t seem to be any worse for the wear because of it as it’s still holding together very well. My best guess is that this book should hold together through several readings with no problem.

Table of Contents

Chapter 1: Introduction

This starts out with a review of the original relational model. It also gets into a couple basic definitions that will get you through the rest of the book. You get into some of the different features of the relational model as well as model vs implementation. You also really get into some good basic theory with the properties of relations, relations vs relvars, and values vs variables.

Chapter 2: Relations Versus Types

OK, you’re getting mainly into types here. You start out with a good discussion on domain-constrained comparisons. It’s quite a lengthy discussion but you kinda need it to understand fully what’s going on. Data value atomicity is next and a couple pages are spent on it. Then you get right into what types actually are as well as scalar and nonscalar types.

Chapter 3: Tuples and Relations

Get ready to be blown away. This is one of my favorite chapters. It defines tuples and relations in a way that you really need to understand if you’re really going to be doing any serious modeling. It discusses what relations are, and some very important consequences. It also discusses NULLS and duplicate tuples. This is truly an excellent chapter.

Chapter 4: Relation Variables

As you would assume, here you get into relation variables and what they mean in reference to database operations. There’s lots of time spent on candidate keys, foreign keys, and views. You then get into a few misc topics like relational expressions, and types. It’s one of those pivotal chapters that you should read for a full understanding of modeling.

Chapter 5: Relational Algebra

Of course, relational algebra is where it’s all at. This is the very heart of SQL and modeling. The meat of this chapter is in the discussion of the operators… restrict, project, join, etc. You then get into evaluating SQL expressions, and extend and summarize. There are plenty of other topics covered that relate to manipulating data and result sets.

Chapter 6: Integrity Constraints

You start out with some discussion on type constraints, but it’s not the meat of the chapter. For that, you’ll need to read the next section on constraint checking in DBs. The biggest discussion is over whether checking should be immediate or deferred. In all though, it’s a pretty short chapter, but it’s worth going over. This is the kind of generic theory that every DBA should know.

Chapter 7: Database Design Theory

Here you get into some discussion of the normal forms. You actually get into some of the reasoning behind them and get into topics such as nonloss decomposition. There’s even a full discussion on 5NF which is something that is usually only touched on.

Chapter 8: What is Relational Model?

You start off by defining a relational model, scalar types, and relational types. Then there are other topics like implementation and foundations. It’s not exactly a long or a short chapter. I find the discussion to be just right for the topic at hand.

-Sean McCown,


Leave a Reply

Your email address will not be published. Required fields are marked *