This is the one book you ought to have if you want to expand your knowledge of online transaction processing (OLTP) and learn how to apply it to the real world. Transaction Processing completely covers the problems faced by OLTP systems and discusses fault tolerance and recovery--the ability of a system to withstand failures of various kinds without dropping the ball. Additionally, Gray and Reuter cover system architecture decisions, monitoring, concurrence (including locks and isolation), scheduling (including deadlock resolution), and file systems. The book concludes with a discussion (circa 1993) of the merits of various hardware and software used in OLTP systems. Although there is no companion CD-ROM with Transaction Processing , the authors do illustrate many of the book's concepts with C source code. As this is a college textbook, you can expect some dry prose and academic approaches to certain problems. Nonetheless, the authors' writing is clear and easy to follow.
It took me a while to read through, but I enjoyed every moment of it. The only thing I can compare it to is when I read "TCP/IP Illustraded vol.1" by W. Richard Stevens - it was extremely interesting and eye-opening.
The book describes transaction processing - not just the transactions in a database, but basically any kind of transaction with ACID properties, that includes all kinds of actions, including "real" ones (moving rods in a nuclear reactor, dispensing money from an ATM), either a local or distributed. There's a good amount of code in it (although the coding style was a bit ugly, probably to save space, but writing directly after the "{" and closing "}" on the same line will always look bad), that supplements the explanations. (most of the figures are useless, but some can help a bit)
The initial chapters on the basics, models, etc. are something that should be taught at most universities and to all IT people. The chapter on isolation (locking, etc.) is probably the best description of the problem I've seen, and although there has been a lot of research on lock-less schemes and there is a preference for them these days, the same basics haven't changed and still need to be used in the same way.
The last few chapters describe something very close to the design of a transactional database (excluding the SQL parser and some other pieces). Those answer a lot of questions on how does the database work underneath and how does it handle the different data organization cases.
It's a book by people who have written such systems, have seen, debugged and solved the problems seen, and written papers on it. At some point I found 20 pages that described problems and solutions that have taken me months to get through.
I'd recommend a few of the chapters even for non-technical people, because of the insight they can give into computing.
This book is a classic for you to know how relational (and other) databases are built. If you want to build a new database for whatever reason start here. The principles of LLR (Locking Logging and Recovery) are beautifully described here. Its something that I feel a serious computer science student with interest in databases should start taking a stab at.