- ISBN13: 9780470385494
- Condition: USED – VERY GOOD
- Notes:
Product Description
This book is intended for IT professionals and students who want to learn how to design, analyze, and understand databases. The material will benefit those who want a better high-level understanding of databases such as proposal managers, architects, project managers, and even customers. The material will also benefit those who will actually design, build, and work with databases such as database designers, database administrators, and programmers. In many projects, these roles overlap so the same person may be responsible for working on the proposal, managing part of the project, and designing and creating the database.
This book is aimed at IT professionals and students of all experience levels. It does not assume that you have any previous experience with databases or programs that use them. It doesn’t even assume that you have experience with computers. All you really need is a willingness and desire to learn.
This book explains database design. It tells how to plan a database’s structure so the database will be robust, resistant to errors, and flexible enough to accommodate a reasonable amount of future change. It explains how to discover database requirements, build data models to study data needs, and refine those models to improve the database’s effectiveness.
The book solidifies these concepts by working through a detailed example that designs a realistic database. Later chapters explain how to actually build databases using two common database products: Access 2007 and MySQL.
The book finishes by describing some of the topics you need to understand to keep a database running effectively such as database maintenance and security.
This book explains database design. It tells how to determine what should go in a database and how the database should be structured to give the best results.
This book does not focus on actually creating the database. The details of database construction are different for different database tools so, to remain as generally as useful as possible, this book doesn’t concentrate on any particular database system. You can apply the techniques described here equally to whatever database tool you use whether it’s Access, SQL Server, Oracle, MySQL, or some other database product.
Most database products include free editions that you can use for smaller projects. For example, SQL Server Express Edition, Oracle Express Edition, and MySQL Community Server are all free.
To remain database neutral, the book does not assume you are using a particular database so you don’t need any particular software or hardware. To work through the Exercises, all you really need is a pencil and some paper. You are welcome to type solutions into your computer if you like but you may actually find working with pencil and paper easier than using a graphical design tool to draw pictures, at least until you are comfortable with database design and are ready to pick a computerized design tool.
-
“Goals of Effective Database Design,” explains the reasons why people and organizations use databases. It explains a database’s purpose and conditions that it must satisfy to be useful. This also describes the basic ACID (Atomicity, Consistency, Isolation, Durability) and CRUD (Create, Read, Update, Delete) features that any good database should have. It explains in high-level general terms what makes a good database and what makes a bad database.
-
“Database Types,” explains some of the different types of databases that you might decide to use. These include flat files, spreadsheets, hierarchical databases (XML), object databases, and relational databases. The relational database is one of the most powerful and most commonly used forms of database so it is the focus of this book, but it is important to realize that there are alternatives that may be more appropriate under certain circumstances. This gives some tips on deciding which kind of database might be best for a particular project.
-
“Relational Database Fundamentals,” explains basic relational database concepts such as tables, rows, and columns. It explains the common usage of relational database terms in addition to the more technical terms that are sometimes used by database theorists. It describes different kinds of constraints that databases use to guarantee that the data is stored safely and consistently.
-
“Understanding User Needs,” explains how to learn about the users’ needs and gather user requirements. It tells how to study the users’ current operations, existing databases (if any), and desired improvements. It describes common questions that you can ask to learn about users’ operations, desires, and needs, and how to build the results into requirements documents and specifications. This explains what use cases are and tells how to use them and the requirements to guide database design and to measure success.
-
“Translating User Needs into Data Models,” introduces data modeling. It explains how to translate the user’s conceptual model and the requirements into other more precise models that define the database design rigorously. This describes several database modeling techniques including user-interface models, semantic object models, entity-relationship diagrams, and relational models.
-
“Extracting Business Rules,” explains how a database can handle business rules. It explains what business rules are, how they differ from database structure requirements, and how you can identify business rules. This explains the benefits of separating business rules from the database structure and tells how achieve that separation.
-
“Normalizing Data,” explains one of the biggest tools in database design: normalization. Normalization techniques allow you to restructure a database to increase its flexibility and make it more robust. This explains the various forms of normalization, emphasizing the stages that are most common and important: first, second, and third normal forms (1NF, 2NF, and 3NF). It explains how each of these kinds of normalization helps prevent errors and tells why it is sometimes better to leave a database slightly less normalized to improve performance.
-
“Designing Databases to Support Software Applications,” explains how databases fit into the larger context of application design and lifecycle. This explains how later development depends on the underlying database design. It discusses multi-tier architectures that can help decouple the application and database design so there can be at least some changes to either without requiring changes to the other.
-
“Common Design Patterns,” explains some common patterns that are useful in many applications. Some of these techniques include implementing various kinds of relationships among objects, storing hierarchical and network data, recording temporal data, and logging and locking.
-
“Common Design Pitfalls,” explains some common design mistakes that occur in database development. It describes problems that can arise from insufficient planning, incorrect normalization, and obsession with ID fields and performance.
-
“User Needs and Requirements,” walks through the steps required to analyze the users’ problem, define requirements, and create use cases. It describes interviews with fictitious customers that are used to identify the application’s needs and translate them into database requirements.
-
“Building a Data Model,” translates the requirements gathered in the previous into a series of data models that precisely define the database’s structure. This builds user-interface models, entity-relationship diagrams, semantic object models, and relational models to refine the database’s initial design. The final relational models match the structure of a relational database fairly closely so they are easy to implement.
-
“Extracting Business Rules,” identifies the business rules embedded in the relational model. It shows how to extract those rules in order to separate them logically from the database’s structure. This makes the database more robust in the face of future changes to the business rules.
-
“Normalization and Refinement,” refines the relational model by normalizing it. It walks through several versions of the database that are in different normal forms. It then selects the degree of normalization that provides a reasonable tradeoff between robust design and acceptable performance.
-
“Microsoft Access,” explains how to build a database with Microsoft Access 2007. This explains enough to get started and to use Access to build non-trivial databases. You can use other versions of Access to work through this, although the locations of menus, buttons, and other Access features are different in different versions.
-
“MySQL,” explains how to build a database with MySQL. This tells where to download a free version of MySQL. It explains how to use the MySQL Command Line Client as well as some useful graphical tools including MySQL Query Browser and MySQL Workbench.
-
“Introduction to SQL,” provides an introduction to SQL (Structured Query Language). It explains how to use SQL commands to add, insert, update, and delete data. By using SQL, you can help insulate a program from the idiosyncrasies of the particular database product that it uses to store data.
-
“Building Databases with SQL Scripts,” explains how to use SQL scripts to build a database. It explains the advantages of this technique, such as the ability to create scripts to initialize a database before performing tests. It also explains some of the restrictions on this method, such as the fact that the user must create and de…
General Purpose, Easy to Customize, Comic Book & Inventory Tracking Database CD
US $39.95
End Date: Sunday May-20-2012 9:41:41 PDT
Buy It Now for only: US $39.95
Buy it now | Add to watch list
When I read and compared this book with other books, I figured this one differentiates completely from others on the market. Rod’s book is VERY to the point, discussing practical aspects of DB Design, and has an easy-to-read tutorial format. It has alot of examples each chapter, making sure you understand the concepts. Its Case Study includes a realistic project and the issues you encounter in the real world when you want to analyze a database system for a business. One of the few books that I love to keep on my shelf. My only problem with the book is its Normalization chapter, which sometimes has non-realistic and hard-to-understand examples. I would rather see examples about real-world scenarios other than Castles-and-knights for the Boyce-Codd Normal-form section, etc. But that is only a fraction of the book. The rest of the book is well-written and great.
Amazon User Rating: 5 / 5
As i was participating in all India software development competition conducted by IBM for Students, i needed to built database for my project (Stock and Portfolio Management Solution) and luckily i found this book.
I completed reading this book in 10 days and took exactly 3 days to successfully design a workable database for my project.
I previously had Database Design subject in my 5th semester of CS Engineering ,but my real understanding about databases came after reading Mr.Rod Stephens book which is simple at its best.
Now with full confident i can mention in my resume that I’m capable of building and designing databases.
Amazon User Rating: 5 / 5
being a developer for 20yrs with pittiful database design skills
i decided to give a thorough look into how to design db solutions
This book covers it from idiot level.
I still call myself idiot level in db design- but an above avg idiot when
designing db’s now if was forced into it with a gun next to my head
Amazon User Rating: 5 / 5
After spending 8 years writing software for a company that didn’t work with databases, I recently found myself in need of writing a new app that uses a database for storage.
Several chapters go into an explanation of the different parts of the database, and key concepts that exist in relational databases. This was particularly helpful for me, having such a limited background with databases.
The book spends a lot of time on requirements gathering, and designing the db around the customer’s needs (and potential future needs), as opposed to just the application’s needs. Some of this was redundant for me personally, but I like the fact that this element was stressed so thoroughly.
The chapter introducing SQL queries is a bit short, but covers the basics (and the things that you will probably use 90% of the time) and points to several large web resources on the subject.
I am quite happy with this book. I feel that I have a much better understanding of the inner workings of the database components, along with an understanding of how to design and implement one. I’m sure that I will come back to particular sections of the book as I work through this project, and on future ones as well.
Amazon User Rating: 5 / 5
Beginning Database Design Solutions (Wrox Programmer to Programmer)
Beginning Database Design Solutions (Wrox)
by Rod Stephens, Denver .Net user group member and speaker
ISBN: 978-0-470-38549-4, Published: 2008, Pages: 552
Author’s Web Site complete URL and/or Author’s E-mail Address
http://www.wrox.com
(search for Rod Stephens)
2008
ISBN 978-0-470-38549-4
Publisher’s Name and Publisher’s Web Site Page for this Book (complete URL),
Wrox
Wiley Publishing, Inc.
10475 Crosspoint Blvd.
Indianapolis, IN 46256
http://www.wiley.com
No Book Image available
Number of Pages: 510
Primary Category best for listing book, review categories and examples:
.NET, Visual Basic .NET, .NET Framework, Sequel Server, Access (Office)
Review Date (April 27, 2009)
Reviewer’s Overall Star Rating (****): 5*’s (out of 5)
Reviewer’s Name
J. K. August, 5915 Braun Way, Arvada, CO 80004
Reviewer’s E-mail Address
jkaugust@msn.com
Reviewer’s Biographical or Current Information Statement
J.K. August is an engineer who uses databases to address engineering information management problems for design basis control in large facilities. (Although similar aspects apply as with some CAD/CAM, these are not CAD/CAM systems.)
Review
This book is pretty good for a rounded examination of designing databases. You need to know a little bit about databases and design to understand this book. I have been doing databases about ten years, as an ancillary job. I only know Access well, but I’ve been exposed to Foxpro, DB2/4, Oracle and Sequel Server. I’ve read all the standard discussions of database design in all the Access books. This book went beyond those, complementing what I knew very well.
The book looks at databases from the broad perspective of having many different users with more than one use requirement. It introduces user-focused techniques to keep designs founded on users’ needs. These include extracting business rules, understanding user needs and translating user needs into business models. It also discusses common design patterns and building a data model. Some areas that it introduces most developers will want to blow off, but these are still necessary for developing excellent applications. These include techniques for mapping the design’s data flows, user interactions, and unpredictable evolution paths.
My own database experience started working alongside much more capable developers than I. Most developers will not want to got through the mundane design steps cited here. They may attempt to dissuade their managers from doing so, based on the additional costs of mapping. Whether they will do this or not probably depends on the scope and quality of the application they design. Our own experience has been to work through these many issues internally, informally, over long periods of internal database use. It is highly unlikely a commercial developer will have the same luxury. Whether people opt to use the full set of tools, available, its comforting to know they are there. For those headed towards larger group database applications, this book clearly explains the levels of an application – front end, backend, and middleware. It explains the reasons for each, problems separately posed, as well as how they can link to web-based database applications.
I found the sections on database design basics as well as non-normalizing database designs review. Some of the information on table field layouts was useful, but may not reflect all users needs for comment text fields in complex, multipurpose applications. I found the sections on documenting and mapping user’s needs most useful, as well as most distressing. I hate to go through these steps myself, and I’m much better than average developers at doing all the mundane documentation stuff.
For the first time, the book explained the causes of database bloat, weird queries and other anomalies that require database compaction and repair. Over the past ten years I’ve never fully appreciated why these are required. Furthermore, I’ve never had a good developer explain to me clearly why these happened or what database maintenance really did. This book did.
The author introduced a few of the more advanced database systems available free from shareware, Microsoft or other download sources. These included MySQL, and MS Sequel server, explaining the value and utility of each. He then introduces SQL – the query language. Though okay for an introductory course, introducing SQL (“See-kwill”), for Structured Query Language and the database applications didn’t add anything for me. However, for someone truly new to databases I could see how that might really be great.
I would have like more information on large database application management, maybe even including how to rebuild a goofed up legacy database. On the other hand, for what it covered it did that very well, and I always want more. I really liked the sections on common data relationship models, common design patterns and building a database data model. I especially like the part for restructuring many-to-many relationships. This alone was worth the cost of the book.
Anyone with a year or two exposure building databases will find this very useful. You probably also need to be working on complex applications and multiple users databases. To read the book easily you must be either be very smart or have a couple years with Access under your belt. By getting more information on common ways to simplify and relate “many-to-many” relationships, this book is invaluable. It may also stimulate more thought on more careful data model development.
I found two annoyances that became distracting from an otherwise great book. One was the author’s tongue-in-cheek style with some of the insider jokes he cites. One or two here and there would be okay, but more than five per chapter gets a bit irritating. (All right, I didn’t count them!) The other was the superficial nature of the demo’ed exercises and code. I just can’t get into some of these example databases. Okay, I realize my interests are very complex, so this criticism is unfair. Overall these weren’t a problem.
I did not attempt to test the code because I wasn’t interested in the types of code demoed, although I did go through the exercises mentally. I found no updates or other errata prior to reading the book, and of course because I didn’t attempt to do the code I wouldn’t know.
“This review originally published in its entirety on the Denver Visual Studio User Group web site, http://www.DenverVisualStudio.net. (c) All rights reserved.”
Amazon User Rating: 5 / 5