Date on Database: Writings 2000-2006

Description

Date on Database: Writings 2000 2006 captures some of the freshest thinking from widely known and respected relational database pioneer C. J. Date. Known for his tenacious defense of relational theory in its purest form, Date tackles many topics that are important to database professionals, including the difference between model and implementation, data integrity, data redundancy, deviations in SQL from the relational model, and much more.

Date clearly and patiently explains where many of todays products and practices go wrong, and illustrates some of the trouble you can get into if you don't carefully think through your use of current database technology. In almost every field of endeavor, the writings of the founders and early leaders have had a profound effect. And now is your chance to read Date while his material is fresh and the field is still young. You'll want to read this book because it:

* Provides C. J. Date's freshest thinking on relational theory versus current products in the field
* Features a tribute to E. F. Codd, founder of the relational database field
* Clearly explains how the unwary practitioner can avoid problems with current relational database technology
* Offers novel insights into classic issues like redundancy and database design

CONTENTS:

PART 1 - Some Preliminaries
CHAPTER 1 Edgar F. Codd: A Tribute and Personal Memoir
Background
Database Contributions
Other Contributions
Personal Memories
Concluding Remarks

CHAPTER 2 An Interview with Chris Date

CHAPTER 3 Good Writing Does Matter
Preamble
Exhibit A
Restriction Conditions in DB2
A Suggested Replacement for Exhibit A
Exhibit B
Exhibit C
Concluding Remarks

PART 2 - And Now for Something Completely Different
CHAPTER 4 On the Notion of Logical Difference
Preamble
Why Is It Important to Think Precisely?
Logical Differences Are Big Differences
Some Things Are Much the Same
Object Orientation
The Unified Modeling Language
Miscellaneous Examples
Concluding Remarks
Acknowledgments
Appendix A: Some Quotes from the Literature

CHAPTER 5 On the Logical Difference Between Model and Implementation
Terms and Definitions
What Are Models For?
Definitions from the Literature
Examples of Confusion: Performance Issues
Examples of Confusion: Many Different Data Structures
Examples of Confusion: Objects
Examples of Confusion: Miscellaneous
Consequences of Such Confusions
Concluding Remarks
Acknowledgments

CHAPTER 6 On the Logical Differences Between Types, Values, and Variables
Types Are Fundamental
More on Types
Values and Variables
Values and Variables Can Be Arbitrarily Complex
Variables Are Updatable, Values Aren't
Pseudovariables
Variables Have Addresses, Values Don't
Relation Values and Variables
Examples of Confusion: Values vs. Variables
Logical Sameness
A Hypothesis
Examples of Confusion: Types vs. Values and/or Variables
Consequences of Such Confusions
Concluding Remarks

PART 3 - Relational Database Management
CHAPTER 7 Why We Need Type BOOLEAN

CHAPTER 8 What First Normal Form Really Means
Some Preliminaries
Data Value Atomicity
Relation-Valued Attributes
Domains Can Contain Anything!
Relation-Valued Attributes Make Outer Join Unnecessary
Relation-Valued Attributes in Base Tables? - The Bad News
Relation-Valued Attributes in Base Tables? - The Good News
A Remark on "NF Relations"
A Definition
Concluding Remarks
Acknowledgments
Appendix A: Terminology
Appendix B: The Information Principle
Appendix C: Definitions from the Literature
Appendix D: So What About Multi-Value Systems?
Appendix E: Formal Definitions

CHAPTER 9 A Sweet Disorder
SQL Tables
The "Select *" Problem
Duplicate Column Names
Missing Column Names
Implications for the UNION Operator
Type vs. Degree
Which Union?
Relation Types
Predicates Revisited
Where Did Column Ordering Come From?
Concluding Remarks
Acknowledgments
Appendix A: Row Comparisons

CHAPTER 10 Double Trouble, Double Trouble
The Cat Food Example
Expression Transformation
Rows Represent Propositions
The Conclusion So Far
Rats and Ratlets
The Pennies Example
Bag Theory
The Performance Issue
Some More SQL Problems
Concluding Remarks
Appendix A: A Tuple-Bag Algebra?
Appendix B: More on Counting Pennies

CHAPTER 11 Multiple Assignment
A Little History
Assigning to Several Variables at Once
A Multiple Assignment Example
Why We Need Multiple Assignment
Why Integrity Checking Must Be Immediate
Assigning to a Variable More Than Once
Semantics
Syntax
Assigning to Several Components at Once
Concluding Remarks
Appendix A: Multiple Assignment in SQL
Overview
The SET Statement: Single Assignment
The SET Statement: Multiple Assignment
The SQL UPDATE Statement Revisited

CHAPTER 12 Data Redundancy and Database Design
The Running Example
Some Prerequisites
Database Design Is Predicate Design
A Brief Review of Normalization
Normalization Is Not Enough
Orthogonality (I)
Another Kind of Decomposition
Tuples vs. Propositions
Orthogonality (II)
What About Views?
Violating Orthogonality
But Isn't It All Just Common Sense?
Other Kinds of Redundancy
Managing Redundancy
1. Raw Design Only
2. Declare the Constraint
3. Use a View
4. Use a Snapshot
Concluding Remarks

CHAPTER 13 Data Redundancy and Database Design: Further Thoughts Number One
More on Predicates
Identity Decompositions
More on Propositions
More on Normalization
More on Dependencies
More on Dependency Preservation
Generalizing Key Constraints
Orthogonality Revisited
Concluding Remarks

CHAPTER 14 Tree-Structured Data
Definitions
A Tree-Based Sort Technique
How Treesort Works
Data Structures
Relational Operators
Implementing TREESORT
Integrity Constraints
Traversing the Nodes of a Tree
Bill-of-Materials Processing
Another Kind of Tree
What About Relation-Valued Attributes?
Concluding Remarks
Acknowledgments

CHAPTER 15 Twelve Rules for Business Rules
Assumptions
A Note on Terminology
Further Preliminary Remarks
Prescription 1: Executable Rules
Prescription 2: Declarative Rules
Prescription 3: Kinds of Rules
Prescription 4: Declaration Sequence vs. Execution Sequence
Prescription 5: The Rule Engine Is a DBMS
Prescription 6: The Rule Engine Is a Relational DBMS
Prescription 7: Rule Management
Prescription 8: Kinds of Constraints
Prescription 9: Extensibility
Prescription 10: Platform Independence
Prescription 11: No Subversion
Prescription 12: Full Automation
Summary
Acknowledgments
References

PART 4 - SQL Database Management
CHAPTER 16 Two Remarks on SQL's UNION
UNION in the Relational Model
Data Type Conversion
Duplicate Rows
Concluding Remarks

CHAPTER 17 A Cure for Madness
The Syntax and Semantics of SELECT - FROM - WHERE
Model vs. Implementation
Nested Functions
Further Thoughts
A Final Observation

CHAPTER 18 Why Three- and Four-Valued Logic Don't Work
Some Basic Concepts
Tautologies, Identities, and Contradictions
De Morgan's Laws
Codd's Three-Valued Logic
The Unknown Truth Value and A-marks
How Many 3VLs Are There?
Codd's Four-Valued Logics
4VL Number 1
4VL Number 2
4VL Number 3
Some Questions of Intuition

PART 5 - Further Relational Misconceptions
CHAPTER 19 There's Only One Relational Model
Celko's Preamble
Chris Date = No Duplicates, No NULLs
E. F. Codd, RM Version I
E. F. Codd, RM Version II
SQL-92 = Duplicates, One NULL
Duplicates, One NULL, Non-1NF Tables
Rick Snodgrass = Temporal SQL
How Many Relational Models?
Concluding Remarks
Technical Correspondence

CHAPTER 20 The Relational Model Is Very Much Alive!
Some Specific Issues
Concluding Remarks
Technical Correspondence

CHAPTER 21 What Do You Mean, "Post-Relational"?
What About Object Technology?
Further Points Arising
What About Object/Relational Technology?
Technical Correspondence

CHAPTER 22 A Database Disconnect
The SMART Paper
The Version 8 Paper
Conclusion

PART 6 - Subtyping and Inheritance
CHAPTER 23 Is a Circle an Ellipse?
Preamble
A Little Background
The Main Argument
Software Engineering vs. Conceptual Modeling?
What About "Colored Circles"?
A Type Inheritance Proposal
Technical Correspondence

CHAPTER 24 What Does Substitutability Really Mean?
What Is LSP?
The Liskov Substitution Principle
A Behavioral Notion of Subtyping
The Liskov/Wing Paper: Assumptions
The Liskov/Wing Paper: Objectives
The Liskov/Wing Inheritance Model
The Running Example
Preconditions and Postconditions
Covariance and Contravariance
Extending the Example
Extension and Constraint Subtypes
Substitutability Defined

PART 7 - Relational vs. Nonrelational Systems
CHAPTER 25 Models, Models, Everywhere, Nor Any Time to Think
Modeling in the UML
What Does "Model" Mean?
Miscellaneous Observations
Concluding Remarks
Postscript

CHAPTER 26 Basic Concepts in UML: A Request for Clarification
Some Immediate Discoveries
The OCL Book
The UML Book
Types, Classes, and Domains
Further Puzzles
Concluding Remarks

CHAPTER 27 A Comparison Between ODMG and The Third Manifesto
Preamble
Overview
Objects
Atomic Objects
Structured Objects
Collection Objects
Literals
Types, Classes, and Interfaces
Inheritance
Object Definition Language
Object Interchange Format
Object Query Language
Summary
RM Prescriptions
RM Proscriptions
OO Prescriptions
OO Proscriptions
RM Very Strong Suggestions
OO Very Strong Suggestions
IM Prescriptions
References

CHAPTER 28 An Overview and Analysis of Proposals Based on the TSQL2 Approach
TSQL2 and the SQL Standard
TSQL2 Tables
The Central Idea
Temporal Upward Compatibility
Current, Sequenced, and Nonsequenced Operations
Current Operations
Sequenced Operations
Nonsequenced Operations
Accessing the Hidden Columns
Data Definition Statements
Valid-Time Tables
Transaction-Time Tables
Bitemporal Tables
Statement Modifiers Are Flawed
Consequences of Hidden Columns
Lack of Generality
Imprecise Specification
Concluding Remarks
References

APPENDIX The Role of the Trade Press in Educating the Professional Community: A Case Study
Overview
The Saga Continues
Conclusions
Exhibit A
Exhibit B
Exhibit C
Exhibit D
Exhibit E
Exhibit F
Exhibit G
Exhibit H
Exhibit I
Exhibit J
Postscript
INDEX