Customer Reviews

Beginning Database Design (Wrox Beginning Guides)

5 star:		(5)
4 star:		(6)
3 star:		(1)
2 star:		(3)
1 star:		(3)

 

 

This is possibly the worst written technical book I've ever read. I'd REALLY like my money back. Powell repeats some things over and over and over again. Sometimes, he re-phrases the same concept 3 or more times in the very same paragraph.

For example, I could not even guess how many times he explains that excessive normalization leads to poorer performance most of the time. I would guess he makes that point 30-50 times, and often 2-3 times on the same page. This is just one example, but the book is filled with fluff such as this.

There are also plenty of mistakes and awkwardly worded passages that make reading the book difficult. Many of the diagrams and examples could have been better chosen so as to reduce confusion.

So why did I give it 2 stars instead of 1? Well, there is *some* useful information in this book. I did learn some things from this book, but I'd like to stress that I don't think there is anything that I learned that I couldn't have learned from free sources on the internet. Take a look at http://www.phlonx.com/resources/nf3.php. In addition to that link, do a search on "Entity Relationship Diagram", and you'll have learned 95% of what is in this book.

I almost feel bad making such a critical review, but on the other hand, I feel bad that I spent money on this book. I wish I had another title to recommend to you, but I've got to go looking myself for a replacement for this book.

This book is an excellent medium-level introduction to Database design. As a programmer, I was never really taught how to design efficient DBs or rather the art of doing it effectively. Believe it or not working with databases is more than just using SELECT or UPDATE commands. I believe DB Design is for rather medium to advanced users. So, others complains about the level of this book is unfair and irrelevant in my opinion. But you be the judge of that.

I'm a fairly technical person, but my knowledge of databases was superficial, so I decided to read this book. It is billed as suitable for the novice, and therefore should take things slowly and methodically.

It feels disjointed and poorly structured. The author seems to jump from one topic to the next. But probably the most significant problem is that the author uses terms and concepts before defining or describing them. I can only imagine how confused a true novice might be when reading some of this.

Examples:

He talks about Online Transaction Processing and Data Warehousing without really defining them or giving examples that would help the reader understand what they're used for.

On page 10, there is a figure purportedly showing what a relational database model looks like. However, it uses symbols and lines that he does not explain till later in the book. Without explaining the symbols, what good is the diagram?

Many places, he talks about normalization before explaining what it is. In one spot where he starts to explain normalization, he writes, "Normal Forms beyond 3rd Normal Form are often ignored and sometimes even 3rd Normal Form itself is discounted." He does not explain what a Normal Form is.It's just text that will have no meaning at all to the reader.

He talks about tables and columns before adequately explaining what they are.

In Chapter 3, he covers simple datatypes. First, he explains what a fixed length string is. But in his accompanying diagram, he uses SQL constructs to explain it. The first line of his explanatory diagram is:
SQL> select country||','||fxcode||','||currency

As anyone with programming experience could tell you, explaining what a fixed-length string is is pretty straightforward. But for some reason the author ties it to a complex SQL example, even before he has explained anything about SQL itself.

I almost gave up on the book, but slogged through to the end. It does get a little more understandable, yet I sometimes struggled to figure out just what the author was trying to convey. I found several mistakes, and there is an awful lot of needless repetition.

There seemed to be several cases where the author said things like:

It's probably a bad idea to ever do X, Y, or Z

And then explained how to do X, Y, and Z. It also felt like the author did things like:

Explain how to do T
Note that it was probably a bad idea to do T
Explain how to undo T

Do yourself a favor and look through the book before buying it. Perhaps you'll find it more readable than I have.

In my experienced, the things that this author repeats over and over again are the most common mistakes in data modeling. I have seen over normalization in over 27 projects in my 15 years of experience. The author is simply trying to make sure that data modelers don't make these same mistakes again. For example, the most common performance problem with most relational databases is over normalization. That means that an application developer may have to do dozens of joins to produce the resulting data. I have seen people use as many as 22 joins, group by, and all kinds of business logic in SQL in order to produce one short sentence of data. That also means that some of the business logic will be shifted to the third or data tier and not kept in the correct tier, middle tier, application tier, etc. This ruins the performance paid for by developing the multi-tier system in the first place.

That is fine if the system will be used by one user, but multiply that by 10 million unique users in 12 hours on an enterprise database, and one has a big problem.

One must always consider the purpose of the model, and how the data will be taken out of the model as well as data integrity, security and normalization.

As the title states Beginning Database Design is aimed at people new to database design. The book does a reasonable job introducing this topic but has a fair number of problems.

What I liked:

- Good coverage of the basics - datatypes, ERD, keys, SQL, indexes, normalization, denormalization.

- Exercises at the end of most chapters.

- A case study for an online auction house.

What I disliked:

- The first two chapters can be skipped unless you are completely new to databases.

- The same information is repeated throughout the book sometimes within the same paragraph. While this can be an aid in helping people to learn a new topic it gets old fast.

- Some strange turns of phrase and typographic errors that required me to re-read sections of the book a few times before I understood what the author was saying.

- Not enough exercises.

Overall, a fair introduction whose effect is reduced by repetition and poor writing/editing.

Full disclosure: I received a complimentary copy of the book for review.

I am very impressed with the presentation of the material to cover introductory as well as advanced topics. I am a senior developer and still involved with designing of systems. I regard myself as an expert designer. This is a book you can buy and keep for a long time. There are some topics covered which I have always wondered about in my 25 years of software development, and now I have everything together in one book. Database design is a crucial aspect of all systems and can make or break your system especially in terms of maintainability. This book will surely help you design robust databases that can live long in your application - a must have for every database designer and programmer!

That which i found very useful about this book, was the ability it bestows on one to take/translate an abstract, ordinary typical user sentence like: "we don't want customer orders to be bookable to our website and thereby representing for us a negative quantity value against our stock inventory,if the quantity we have left in stock for the item is actually zero"

and translate it straight into the SQL implementation equivalent. for example: using a table definition to define restrictions to a single quantity-in-stock column , as well as a table check-constraint requiring (quantity-required to be less than , or be the same as, the amount of the quantity-in-stock), one possible SQL implementation equivalent of the user sentence could be shown in T-SQL as:

CREATE TABLE ProductOrderLine
(ProductLineKey....BigInt....,
OrderMatchKey.....BigInt....,
ProductOrdered....Char(6)..,
QuantityInStock....BigInt....,
...CONSTRAINT NonNegativeStockValue CHECK (QuantityInStock >= 0)
QtyRequired.......BigInt......,
...CONSTRAINT CK_QuantityOrdered CHECK (QtyRequired <= QuantityInStock))


In short, Beginning Database Design by Wrox, gives one a useful,solid level of clarity/handle in grasping this direct relationship between your understanding of the business rules and user requirements for the database system and the direct SQL translation of this into SQL code implemention.

understanding the problem matter right from the jump, when you are conducting user interviews, is invaluable in order to revise, better gather/factor-in users perpectives/expectations for what the system should do for them / will help them solve in their individual daily business tasks

The Results: lots of very satisfied customers; resulting from your proficiency in mapping/translating fluently between abstractions ie :ERD's et cetera and their SQL implementation.

This book reminds me of another one in the same sort of carriage, also using this same paradigm ie: translating from trite clue-sentences, directly into the SQL code implementation equivalent.

That other book was titled: [Data Management : Databases & Organizations] and it has for ISBN: 0471715360

Beginning db design by wrox can bring to you -(if you start your database design study trek here, plus, understand and practise designing databases at this level), a shorter transition to mastering design & implementation of databases.

The concepts discussed ie: business rules & their direct implementation, reverse-engineering/backtracking -(denormalizing) a db design ,OLTP ,datawarehouse and OLAP database modelling, A study of The Database Objects (you'll use in your implementations) viz: sprocs -(a.k.a: stored Procedures) ,triggers,functions,views,indexes,
& other necessary concepts such as: B-trees,Hash tables, Hash keys, Replication, RAID arrays, clusters & partitioning

are in my view critical to producing solid , detailed, database designs & to the construction of effective database systems.

from an overarching performance perspective, a well designed database is only second in importance to operating system considerations, -(if you go by the 'Pyramid of Performance' as described in page220 of 'Portable DBA' by Bersinic & Giles; ISBN:0072230169)

in summation:
A famous irish tale is told of a tourist, unfamiliar with a lieu, who, while lost trying to find his way to a well known monument, stopped to ask directions of a local irish man. the irish man replied famously: " if i were going there, ...i would not start from here"

moral of story: There are many books that will teach you approaches or take you on all sorts of roads, beaten paths & straits as you make your approach / journey to the sometimes puzzling & forrested frontier leading to the kingdom that is database design. this book is one of the better,better places to commence your trek from as you make your way to total db design mastery.

believe me, sooner or later & eventually, this translation skill/ability/know-how, is that which you will need to consistently use and definately needs to compute for you, in order to cut to Pro.

enough said!

ps: for other solid, companion roads and approaches to take, see book review on: 'Designing effective database systems; ISBN: 0321290933.

pps: if you are just after learning how to construct/choose good indexes in real-life practise, check out: 'Relational Database Index Design and the Optimizers' ; ISBN : 0471719994 ; plus -(still on indexes), if you can, also check out Joe Celko's 'SQL for Smarties' (3rd Edition); ISBN: 0123693799

cheers. :-):-)

I have read the first 5 chapters of this text and I can't believe they are marketing this text at beginners. If I was a beginner I would get absolutely nothing out of this book. I am not a beginner and it still offers nothing of value in the first 5 chapters. It uses database-related terms before they are ever defined and then when they are defined the reader is left with the feeling - "What did that mean?". The examples are not well developed and add nothing to the text. I am surprised that the publisher did not have some "beginners" read this text and comment. I do not have the stamina to finish the book.

I really enjoyed this book. Yes, the author does sometimes repeat himself 1 too many times (difference in design between online and data warehouse dbs for example is mentioned quite a few times as the others have pointed out) but overall I found the book well written and easy to follow.

I would classify myself as a power user when it comes to working with databases; although I don't have an IT background. I sometimes struggle to find the right book when I want to learn about an IT topic (databases or other) - one that would not be too basic but also one that isn't written only for IT people. This book stroke the right balance for me. It helped me understand some new concepts as well as refresh some important basics.

Highly recommended.

I have been writing software requirements for a number of years and had to pick up database concepts on my own so I'm not a total novice.

With that in mind, I got a lot out of reading this book. The first few chapters do a great job of explaining the history of early database types and then introduce modern designs such as relational, object model, and data warehouses. I also enjoyed later chapters which get into more details about star and snowflake schemas in data warehouse design, and normalization. The chapter on SQL was too brief, but he did a good job with explaining joins.

In many of the one star reviews, it sounds to me like these customers were hoping for a more advanced book.