Refactoring Databases: Evolutionary Database Design

by Scott W. Ambler and Pramod J. Sadalage

Book Overview

Refactoring has proven its value in a wide range of development projects-helping software professionals improve system designs, maintainability, extensibility, and performance. Now, for the first time, leading agile methodologist Scott Ambler and renowned consultant Pramodkumar Sadalage introduce powerful refactoring techniques specifically designed for database systems. Ambler and Sadalage demonstrate how small changes to table structures, data,...

• Format: Paperback
• Language: English
• ISBN: 0321774515
• ISBN13: 9780321774514
• Release Date: March 2006
• Publisher: Addison-Wesley Professional
• Length: 384 Pages
• Weight: 3.05 lbs.
• Dimensions: 0.9" x 7.0" x 9.2"

Customer Reviews

Bringing the Mountain to Mohammed

Much more beautiful code is being written as a result of Fowler's Refactoring; the Gang of Four's Patterns; Beck's Test Driven Development; etc. Unfortunately the database development community either hasn't applied these principles & practices or hasn't bothered to read about them. So Scott and Pramod have brought the mountain to Mohammed with Refactoring Databases. Most database developers I interact with are loathe to change a database design. It's scary and risky! As a result most database applications continue to incur increasing technical debt, entropy, and ugliness. In my work as an Agile Coach and Agile Data Warehouse developer I hardly ever get to see a truly beautiful data model in production. This book, when applied, will go a long way toward helping database developers create beauty and avoid the scariness of changing data models. This book is a must read for database developers, and I reserve "must read" status for very few books. Next thing we need is a database patterns book.

Answers tough questions

I've done a lot of refactoring and restructuring programs and always had to deal with the problems involved with changing the layout of persistent storage. This book describes solutions for those issues I encountered. It explores some tough questions, like how to refactor a database used by multiple applications, only one of which is currently undergoing modification. I recommend it to anyone involved with the database side of systems, whether an administrator or a programmer who uses one.

Excellent refactoring reference and eye-opening book

This is an excellent book that, in my opinion, serves two purposes. First, it is a compendium of well thought-out ways to evolve a database design. Each refactoring includes descriptions of why you might make this change, tradeoffs to consider before making it, how to update the schema, how to migrate the data, and how applications that access the data will need to change. Some of the refactorings are simple ones that even the most change-resistant DBAs will have used in the past ("Add index"). Most others (such as "Merge tables" or "Replace LOB with Table") are ones many conventional thinking DBAs avoid, even to the detriment of the applications their databases support. This brings me to the second purpose of this book. Many DBAs view their jobs as protectors of the data. While that is admirable, they sometimes forget that they are part of a software development team whose job is to provide value to the organization through the development of new (and enhancement of existing) applications. One of the best DBAs I ever worked with viewed himself as a "Data Valet." He said his job was to make sure the data was presented to applications when and where they wanted and to protect the doors from getting dinged while under his care. Through its first five chapters and then the refactorings that follow, this book will help DBAs expand their view of their role in the organization from one of simply protecting data to one of enhancing the value of data to the organization. This book is one that you'll keep on your reference shelf for many years to come. Highly recommended.

Finally!

It's been almost 7 years since Fowler's Refactoring book, and now the database community has finally caught up with the rest of us. This book shows how to refactor a relational database schema, working you through the detailed process steps for doing so and providing the source code for implementing more database refactorings than I would have thought existed. The first five chapters describe how to go about database refactoring. Chapter 1 overviews the idea that you can evolve your database schema in small steps, a radical departure for many traditional DBAs. It also overviews the need for supporting techniques such as agile data modeling, database regression testing, and version control of your data models and scripts. I would have liked to see more coverage of these topics, but at least the modeling material is covered in Ambler's Agile Modeling book and there are some great SCM books out there. Chapters 2 and 3 walk through the process of implementing a database refactoring, first through the simple situation where there is only a handful of applications accessing the database. I guess this sort of thing happens in smaller companies, but most of the time you really have to worry about scores of applications accessing your database which is a much harder situation. This is actually the focus of Chapter 3 and of the presented solutions in Chapters 6 through 11 which provide reference implementations for all of the database refactorings. This approach belies the true strength of the book: it reflects actual experience in large organizations, not just the theoretical pie in the sky stuff you see from other authors. Chapter 4 focuses on deploying database refactorings in production, providing detailed instructions for how to roll refactorings between various sandboxes. It importantly describes how to merge the refactorings of several teams together. If you have 100 applications accessing a shared database, then potentially you need to manage the refactorings coming from 100 different development teams. Of course it would never be that bad, but even merging refactorings from 10 teams would be tough. This might be where the technique falls apart because many companies likely don't have data managers who are skilled enough to do this sort of thing efficiently enough to keep up with agile developers. We need new tools, so hopefully companies like Oracle will build something for us. Chapter 5 describes a collection of best practices and challenges pertaining to refactoring databases. The authors share their experiences as well as identify potential issues, such as a lack of tooling and agile expertise within the data community, that could slow adoption of this technique. My guess is that the smarter teams within companies will start doing this stuff right away, for the most part it's pretty easy technically, but that bigger companies will struggle to change as they always do. Chapters 6+ are reference descriptions for the individual r