Database Design and Implementation 1st Edition

I'm in the process of developing a database, and I bought all the books. Hands down, this one is the best. The others are theoretical, tedious, and describe only general algorithms. This one shows actual code, which makes it way easier to wrap your head around doing an actual implementation. It is clearly written, contains no fluff, and gets straight to the point. Even now, 10 years after it was written, it's still mostly current. I am unaware of any other book that comes close.

This is the only time I've written an email to the author to thank him for writing a book. I'm a professional developer who needed a better understanding of db internals - not any specific area, but rather the 'big picture' and how the main components interact. The book and the SimpleDb source are simply wonderful. And unlike many technical books, it is brief, clear, and to-the-point.Anyone working at the persistence layer, either SQL or NoSQL, could hardly do better than to start with this book.

Very nice

I'm not thrilled with this book, but of the three database design and implementation textbooks that I've read, this book is the most practical. I won't comment on the first part of this book, because the copy sent to me was bound with pages out of order and missing material.To me, the most useful thing about this book is that the author included his own relational database implementation, called SimpleDB, which he wrote in Java; a nice high-level programming language. SimpleDB illustrates the database concepts by concrete example. This is tremendously helpful.Among the many topics covered, I thought this book, paired with the SimpleDB source code, do a good job of communicating how query plans and table scans realize abstract relational concepts in working software. It was also very helpful to see a working example of how transactions and recovery can be implemented.I was disappointed that this text did not present maps of the territory, in the form UML diagrams of SimpleDB. That would have been a very concise way to communicate the big picture. Many pages are spent explaining the SimpleDB source code at a low level. A few pictures would have been worth thousands of words. I'm not sure the prose entirely makes up for the lack of such diagrams.I was also disappointed that SimpleDB source code (at the time I reviewed it), made use of static references and the singleton pattern; and violated the Law of Demeter for Functions a bit too often. Those practices are considered harmful because they obscure relationships and make software difficult to test and modify, something that the student is specifically tasked with doing. Moreover, using those practices sets a bad example for students, who probably won't know that they shouldn't emulate such practices.Overall, I'm not aware of any single textbook that does a great job of explaining database design and implementation. However, as introductory texts go, this is my favorite so far. I give this book four stars out of five, but only because I'm grading on a curve! Anyone wishing to understand the subject comprehensively will still need to supplement their knowledge by referring to the other, more abstruse, textbooks on this subject.

Refresher and ReferenceMy perspective as a reviewer is not as a student, but rather as a practitioner. When I was a computer science student (early 1970's), there were no courses in database management; data lived primarily on magnetic tape, and the few commercial "database management" systems that existed were not general purpose tools. Commercial relational database systems did not appear until the late 1970's. I helped create one of the first, and have continued working in database design and transaction processing ever since.However, my career took me a bit afield from 2000-2005, and recently I wanted a refresher and reference to help me catch up. Sciore's book has met that need brilliantly well. Its solid grounding in familiar concepts and practices means its takes me only a minute or two to find any fact I need - in sharp contrast to the weighty tomes about databases that have long strained both my bookshelf and my patience.A timeless value emerges from this book's careful organization and straightforward treatment of the often-messy details of database design and implementation. It elucidates the three-level relationship between data; the tools required to manage and query data; and the programming concepts best suited to implement such tools. This value will persist even after SQL and Java pass away.One further bonus should be mentioned. The "Suggested Reading" sections present at the end of each chapter provide a succinct survey of relevant information, filtered by Sciore's understanding and experience. If those sections were extracted into a separate book, it alone would be worth the price of this one.

The second edition is out now which makes this book even more valuable now.This is an outstanding and unique book that goes into the practical details of database implementation with working code. It's very surprising that of the many tomes of books written on databases there is hardly any (I know of none) that explains the implementation in the manner of this book.Being able to see real code and and working with that is invaluable in understanding databases in detail. Most big name texts on databases glosses over these details; this book provides those missing details.

The book came on time. The condition was as stated.The value of the book for me is the implementation of a simple database. Database systems are complex and a theoretical explanation does not really give the details you want. To understand a database engine or any other software you need to write one. Unfortunately, most database books are just theoretical and boring. Explaining how a system works using theory can also be very confusing. They do not go into the details of how an engine actually works: how is a transaction represented and how does a transaction interact with the paging system and the write ahead log?The book answers these questions. The theory makes so much more sense once you make an attempt to understand the implementation.The database implementation of this book is not complete, but there is enough there to get you going.The coding standard is not great either. The implementation of the database is in Java.The book achieves its aims if you are interested in how a database engine is implemented. After having a look at this engine you start to look at other production ready database engines such as the H2 database engine.