Applied Mathematics for Database Professionals (Expert's Voice) [Hardcover]

If you're responsible for the design, correctness, or performance of any relational database system, whether you class yourself as a developer or DBA, you should read this book.

If you're interested in the theory of databases, you'll love the whole book. If you tend to discard theoretical books by saying "yes, but what practical use is it?" you should still love Chapter 11; and to get the best from Chapter 11, you need to read Chapter 7; and to make chapter 7 easy to read you ought to work your way through the first six chapters.

A database is nothing if the content is not correct so, ideally, we have constraints to make sure that data literally cannot exist in the database unless it is correct.

We have tuple constraints (rules about the values in a single row - for example in an employee table with columns job_grade and salary, the value of salary can only exceed 30,000 if the job_grade is higher than `E'); we have table constraints (rules that restrict the collection of rows in a table - for example, only one employee can have the job-title `CEO'); we have database constraints (rules that restrict the data in one table based on data existing in other tables - for example an order can only be created in the orders table for a product that exists in the products table); finally we end up with "state transition" constraints (rules about how the data may change - for example, an employee may only become a senior vice president if they are currently a vice president).

The authors take us step by step through the expanding scope of constraints showing how to specify constraints as statements of formal logic starting, in fact, with types - the specification for the legal values that an attribute (column) can take.

The whole thing is a clear and brilliant presentation of what you are really trying to achieve when designing a database and creating the supporting code. Then, in chapter 11, the authors take you from logic to code - presenting six models for coding up constraint management using Oracle-specific examples.

The six models range from the simplest (with maximum impact from serialisation and locking issues) to complex (with the minimum necessary serialisation and locking). The examples, and explanation of the issues, give you a wonderful insight into how difficult it is to enforce data correctness even from "inside" the database, and should be mandatory reading for all developers who want to ensure that their programs don't generate inconsistent, or incomplete, data.

Summary: Some people will find the symbolic logic heavy going, but everyone who has to deal with designing or coding an Oracle database ought to read chapter 11 and do their best to read chapter 7.

This book from Lex de Haan (RIP) and Toon Koppelaars is a very welcome addition to those relatively few technical volumes to date that attempt to apply the rigours of a sound theoretical mathematical framework to the Relational Model, and the varied and various manifestations thereof.

This well written and well structured book takes the reader gently through rudimentary relations and sets in Part I, to the more complex database-related aspects in Part II, and finally culminating in Part III where the theoretical is applied to the practical - in this case through Oracle, but will equally apply to any of the major Database Management System (DBMS) vendors.

Although the reader is taken `gently' through the learning process, I believe that any experience in Formal System Specification would be a great help to the reader, similarly with any degree of knowledge of relations and sets. With no knowledge of either of these then the curve may not be so `gentle', but what can be assured, however, is that the exercises are well enough designed to bring the knowledge levels up appropriately as the book progresses.

Conversely, what probably isn't of great assistance is a high degree of proficiency with SQL, with its manifold attendant shortcomings and deficiencies. The difficulty here arises where the reader will tend to approach it logically from an SQL perspective (with the perhaps now instinctive mental workarounds), where this book approaches from a much more logically complete, theoretically sound, and neutral angle.

That said, however, there is much of value in this book for the seasoned SQL practitioner, if only to alert as to how incomplete the current DBMS offerings are, how this (potentially) compromises data integrity on several levels (tuple, table, database), how to avoid those same shortcomings, and on how to exploit the maximum declarative constraining from those same DBMSes in their current incarnations. For the not so seasoned, it will lay a solid, sound theoretical basis that will serve very well throughout a career with databases.

Well written (if very technical). Would recommend if you are a database designer/developer, made me think about DB's from a different angle