Packed with needed knowledge in humorous manner! It is way easier to read than any SQL I have ever encountered... wonderful job done. I will definitely look at the books in the series first before I buy computer books of other technologies from now on.

Before purchasing this book, I read the reviews and was instantly hooked on the concept of a technical book that would use humor, imagery and other off-beat approaches as teaching tools. Unfortunately, after reading the entire book I feel that these techniques were way over utilized. The figures are very busy because the author feels you will remember words if they are attached to an image. In addition there is very little information conveyed on each page. I found myself thinking "why doesn't the author just get to the point already instead of making me flip through 10 pages?" The book probably could have been condensed down to a half or quarter of its size. The "exercises" are also quite uninspired. I didn't learn anything more from them than I would reading an intro to SQL webpage.

Anyone who has a technical background such as engineering or computer science will probably feel the same as I do. However, for those who have weak or moderate computer language skills may find the book a breath of fresh air as compared to dry, boring long-winded textbooks. I would strongly recommend reading through the first chapter if at all possible to determine if the teaching style is a good fit for you. Do a search on the net as the first chapter is freely available. I learned this after I bought the book!

This book is an excellent book for beginners to SQL that have a tough time using books to technology. The book is a very long read if you are already comfortable basic concepts like joins. However, it does have good chapters on table and database design. For the length of the book, I expected more advanced topics like stored procs.

At first I was a little thrown off by all the images and quips (I guess I'm used to boring, dry guides). After a while I was actually drawn into the book and how it guided me through learning SQL. I must admit that I had a somewhat rudimentary understanding of SQL but after completing the book my queries a sharper & more complex.

I do want to put it out there; this isn't really a reference book, it's primary focus is to teach you the fundamentals of SQL, not really the fancier functions or tricks that you can use in SQL.

There was only one short coming to the book; some of the samples did not contain answers. I know it's petty, but there were times I would've liked to have known the answers.

I would confidently recommend this book to anyone looking to learn SQL.

If there is one book in head first that deserves attention (apart from Servlets book) it is this. All the programming books are great anyways (Exception is Head First Design patterns, PLEASE DONT BUY that one!).

SQL Head first helps in visually knowing what is going to happen, especially when running mutltiple OUTER JOINs and writing subqueries etc. Thanks to this book (and a combination of SQL Cookbook and SQL Tuning (for more advanced people)).

Here are some of positives of this book :
1.) Starts out at very basic level (this can be annoying for some folks, who already know much of the stuff, but then this book is not for you then, try SQL Cookbook or SQL Tuning). I would still say this book can be kept as a good reference, as even seasoned people can be helped from visually organized "notes" in there.

2.) Advanced Select section is awesome, JOINS and subqueries and Associations are explained very well. (In this case diagrams help in better visualizing things and helped me understand and recall the concepts really well, After a long time i am not trying to "remember" what the syntax of a clause is in SQL, instead i just visualize things (an example of this would be a sum(xxx) and a group by ... and how the diagram illustrates it very neatly, if i want to use a complex JOIN query or a multiple group by, i don't have to google anymore).

Cons :
1.) Some of topics could have been covered in a better way, example tuning etc.
2.) is @ medium level, for advanced topics i still refer to SQL cookbook or tuning book (by Dan).

All in all it was a great buy for me.

Regards
Vyas, Anirudh

The book was in the condition as was described: completely new. and fast shipment. thanks

If you are developer and need to refresh your SQL knowledge or if you want to learn SQL very fast and with some fun - it is book for you. This is not a book for Database Administrators. Second disclaimer - they use examples for MySQL, so if you are using different DB, you need to translate some of them.

I believe I do not need to convince you how good are "Head First" series, so let's focus on the content.

It starts from explanation what DB is and some easy SELECT queries, so you can read this book without any knowledge in DB world.

Next chapters cover UPDATE, INSERT, DELETE, primary/foreign keys, ALTER, ORDER BY with most common aggregation functions (like MAX, AVG), inner/outer joins and more. There is also place for some theory and DB patterns.

As always, couple of the last chapters contains a bit more complex information like roles and privileges, constraints, unions, intersections and subqueries.

In summary, it is very good book that gives you short introduction to DB world (with some advanced knowledge). I do not know anything that is required in my day to day job that is not in this book.

Straight up best tech manual I've ever purchased. Feels like a 101 language workbook, reads like a breeze, and at the end of the sitting you know something. It's not dry, it's not tedious, and its playful approach doesn't in any way water down its comprehension.

Truly an excellent effort, really happy I purchased it, please keep writing these.

From the very beginning I enjoy reading HF series books. HF SQL is up to the first half of the content very boring and I would even say it can be dangerous for an SQL beginners. It tries to teach them with the style of examples where first is bad design and after a correct solution follows. There is too much space in the book describing intentionally first "let's try" examples. The consequence is that the correct solutions that follow later are not very clearly visible. I think this is quite opposite grasping of the method how HF series book should be written. The "original" HF books from K.Bates etc. directly evolves simple examples and evoke the need of a reader to find out how it all works.
And again when you see the same pictures in the 10th HF series book it ends to be a positively provocating or joking.
The second half of the book can be a litle bit useful even for experienced SQLers. I mean to fill-in the gaps of their SQL knowledge. It is still HF series books so it is easy to read very quickly thus very good for always busy people.

Of all the books I've read for SQL, this is the one that I wished I had when I was getting started. Like other titles in the Head First series, this book is written for people who aren't into reading textbooks. The book is not only very imformative and complete, it is also quite fun to read. For anyone looking to get their feet wet with SQL, this is the place to start.

I think this book is for those of us who are having a hard time grasping the concept of SQL. Not for the experts but the rest of us. It put's things in a way that most people can absorb the information.

I have bought severl SQL books in the hopes of understanding and this is the first one that really got through to me.

In typical Head First style, this book is a hip trip down SQL lane, gently imparting concepts and techniques that stick to your brain.

The book elegantly mixes the core concepts of writing SQL with solid principles of database design (with more than a dash of good humor). There are tons of exercises and examples, which help you to not only understand the language concepts being taught, but you get a good sense of good (and bad) database design at the same time. The author reasons that we often times are called upon to work with or fix bad a database design, so the book teaches you just that. And of course, you learn how to create a good design at the same time.

What it is not: A comprehensive SQL reference. It is based mostly on MySQL as a database (the recommended tool to use for completing exercises for this book), and the book teaches techniques that might not work in other databases. I used Microsoft SQL Server 2005 for my exercises, and I spent a lot of time looking up how to get some functions to work; in some cases MS has a slightly different structure, but in some cases there is no comparable function in MS SQL (of course, the opposite can be said about MySQL as well - MySQL can't do everything some other databases can). However, in the end, this aided in my learning about SQL, as well as learning about the strengths and weaknesses of the various databases.

If you are a seasoned DBA or a SQL guru, stay away...you are there already. But if you just starting out, you can't go wrong with this book.

Great step-by-step instructions for those who want to start with the basics to learning SQL. Very text-book like: it includes practice exercises for each concept taught. The "head-first" books do a nice job of keeping things light by including quirky pictures and interesting subjects for practice exercises (clowns, drinks, etc.)

I am enjoying this book. It is quite basic, but a good refresher for me to tune up my SQL skills.

Before I talk about Head First SQL, let me tell you about other database books I have used in the classroom. I teach an enterprise databases sequence (DBs I and II) at a tribal college in Montana. On the course evaluations for this sequence, students have a common complaint: "Liked the class. Hated the book.", "The book was painful to read.", "Please get a different book!"

Each year my colleagues and I are on the watch for a better, more engaging database book. We have tried three books over the past five years, but the difference between those books is like the difference between shades of grey. In the classroom, most of my time is spent mediating the daunting abstractness of those books or breaking down huge lumps of difficult technical material written in plodding and pedantic prose. This year a spot of color showed up: Head First SQL!

I discovered Head First SQL too late to use it as the primary text for my Fall quarter DBs class, but I liked it so much, I added it as an optional textbook for the quarter and told my students it would be the main textbook for the Winter quarter. I did so because the energy of the class was waning rapidly, and the book I had originally chosen was not helping. I needed to add some excitement to homework and lectures. Within two days of using Head First SQL, the classroom became a far more engaging environment.

I compiled this list for anyone interested in learning databases and SQL, especially anyone who teaches it.

Eleven Things I like about Head First SQL:

1. The book starts where my students start. The first questions my students have are questions of relevance: Why do I want to know this? What have I done before that's like this? What will this material add to my career and my life? Head First SQL starts by ushering the student through those questions: What is a database? Who cares about databases? What will a database do for me?

2. My students are able to read SQL, think SQL, and write SQL after the first chapter. Head First SQL starts students on the command-line, the same command-line professional database administrators use during 80-95% of their workday. My students start out with good command-line habits like using a DESCRIBE statement to view database structure and columns before writing a SELECT statement that references those columns.

3. The book invites my students to make mistakes and anticipates the most common mistakes I see students make. On quizzes, students who've dug into the book don't make those mistakes again.

4. The book's sequence of topics fits the way I teach and the way my students learn: queries come before design and theory. Head First SQL does not set out to be a comprehensive database design book, but it does an excellent job of immersing the learner in the critical thinking that goes into database design and table design strategy. I applaud Lynn Beighley and the Head First Team. They have laid an excellent foundation for the learner to smoothly transition into abstract database design concepts such as normalization, primary and foreign keys, entity-relationship diagrams (ERDs), and E.F. Codd's 12 principles of relational design.

5. Students don't read the book. They work the book. They play the book. They do the book.

6. Like Socrates, Head First SQL pushes my class and I to ask deeper questions about data, information, table design, normalization. Three different times during fall quarter, we had substantive arguments about which data types to use for certain columns. To hear my students using critical thinking and applying it to table design strategy is rewarding.

7. Like a guide, an outfitter, a trusted companion, HF SQL walks beside the student. The books I have used before talk down to students, talk over their heads, or just plain pontificate.

8. Theater in a database classroom? Yes. My students and I act out things like "Confessions of a NULL" -- fun, mysterious, memorable -- a great way to turn an abstract concept into a concrete and palpable one.

9. At conferences, committee meetings, training seminars, my colleagues and I talk about student engagement and the new "three Rs": rigor, relationships, and relevance. Using Head First SQL in my classroom changed my class noticeably, and I attribute that change to Head First's focus on those three Rs. My students started showing up early for class, spent more time in the lab outside of class, and performed far better on quizzes.

10. My quizzes and tests consist of sample tables and data. The open-ended questions on those tests ask students to write SQL to solve problems--a daunting task but the best way to assess whether students really "get" the concepts. In the past, students scores have ranged from 10% to 87%. A score of 92% was rare. A score of 95% almost unattainable. With Head First SQL, that range increased to between 70% and 98%. If that's not proof of Head First SQL's effectiveness, I don't know what is.

11. You will laugh your [body part here] off! And be warned: no matter what body part you substitute into the brackets, you will laugh several other body parts off as well.

I highly recommend this book to anyone teaching or learning SQL, relational database design, or MySQL.

Before reading this book, I knew almost no SQL. Head First SQL was a very fun entry into the world of talking to tables. Despite my near complete ignorance, I was very quickly creating tables and extracting information from them. I found the explanations very clear and the examples entertaining. Once or twice an exercise would throw me for a loop; but there was enough information in the book to figure them out.

Perhaps most surprising to me was that this is not just a beginner's book. The last half of the book gets into some relatively complex topics. This was great. I'm generally not a big fan of "fun" textbooks, and part of that is because they often have a tone of talking down to the audience. This book did not do that at all.

I have recommended this book to anyone who's mentioned to me that they were interested in learning SQL.

I'm generally a "learn what I need to know when I need to know it" kind of web developer. Though I have had some experience with SQL, I've always felt a little frustrated that I sort of skipped learning the foundations of SQL and went hurtling straight on into the database deep end. I had heard great things about the Head First series so decided to finally spend some time with a SQL book. I love the book. On top of being very humorous and witty, it helped me understand concepts on a level that you just can't get from a resource-type book. I especially liked the section on table altering.

I had no experience at all with HTML, and this book was an excellent place to start. Very easy to read and understand, I got through it in about 5-6 days. I recommend this book for anyone looking to learn about creating web pages. Even if you already know the old HTML, this is a good book to get you on track with the new technology - crossing over into XHTML and using CSS - it will help you learn HTML the right way.

Probably the publisher changed the name after the book was written but before publication in order to reach a wider audience.

Still, I'm glad I bought "HeadFirst SQL" because it has allowed me to better understand outer joins, inner joins, natural joins, intersect, union, sub-selects, views, etc.

The book does not explain any of the differences between MySql and other databases such as Oracle, when it comes to generating keys for "inserts", using "create" statements, the syntax of the "alter" statement, the ability to use a "check" constraint, granting and revoking security, etc. Only MySql version 5 syntax is taught, and it is taught in very great detail.

As a developer who uses Oracle 10g, I found the first half of this book was barely worth skimming. Much of it is specific to MySql and would generate syntax errors if applied to an Oracle database. The 2nd half of the book however is worth reading carefully and even re-reading; it's fun to read and imparts a great deal of valuable information about the things I mentioned in the first paragraph.

In summary, the book is worth the money for people who already know a little SQL but want to understand much better how to write DML (data manipulation language). It is not helpful for non-MySql programmers who want to learn DDL (Data Definition Language)..

Post Script-- The single biggest improvement I would suggest for not only this book but all "Head First..." books is to add page numbers where related information can be found. It is very frustrating, for example, to try to do the quiz on page 463 on writing a specific SQL query-- the book does not show on page 463 what page to flip back to in order to see the actual table definitions-- it could be thirty, forty pages back or it could be a hundred pages back, there is no way of knowing.

I am very glad I bought Head First SQL because it has allowed me to better understand outer joins, inner joins, natural joins, intersect, union, "except", sub-selects, etc.

However, it is totally accurate to say that 100% of the book with no exceptions whatsoever is entirely devoted to the specific syntax of MySql version 5.

If the reason for reading the book is to learn the types of things I mention in the first paragraph, this book is still very worthwhile, even for a developer who uses a different database, for example Oracle 10g.

However, be aware that there are huge differences between MySql and other databases (such as Oracle) when it comes to generating keys for "inserts", using "create" statements, the syntax of the "alter" statement, ability to use a "check" constraint, etc.

As a developer who uses Oracle 10g, I found the first half of this book was barely worth skimming through without bothering to do the exercises. The 2nd half of the book however is worth reading very carefully and even re-reading; it's fun to read and imparts a great deal of valuable information about the things I mentioned in the first paragraph.

In summary, the book is worth the money for people who want to learn to understand how to write advanced "select", "update", and "insert" statements. It's not helpful for non-MySql programmers as a book for learning DDL such as "create", "alter", etc.

Post Script-- The single biggest improvement I would suggest for not only this book but all "Head First..." books is to add page numbers where related information can be found. It is very frustrating, for example, to try to do the quiz on page 463 on writing a specific SQL query for finding the contact information about web designers-- the book does not show on page 463 what page to flip back to in order to see the actual table definition-- it could be thirty, forty pages back or it could be a hundred pages back, there is no way of knowing.

I haven't met a Head First/Head Rush title I didn't like, and this one is no exception... Head First SQL: Your Brain on SQL -- A Learner's Guide by Lynn Beighley. It's perfect for someone diving into the world of relational databases for the first time, as well as those who don't do it often enough to feel comfortable with things like normalized forms and outer joins. And along the way, you'll have plenty of fun picking up the skills you lack/need to reinforce.

Contents:
Intro; Data and Tables - A Place for Everything; The SELECT Statement - Gifted Data Retrieval; DELETE and UPDATE - A Change Will Do You Good; Smart Table Design - Why Be Normal?; ALTER - Rewriting the Past; Advanced SELECT - Seeing Your Data With New Eyes; Multi-table Database Design - Outgrowing Your Table; Joins and Multi-table Operations - Can't We All Just Get Along?; Subqueries - Queries Within Queries; Outer Joins, Self Joins, and Unions - New Maneuvers; Constraints, Views, and Transactions - Too Many Cooks Spoil The Database; Security - Protecting Your Assets; The Top Ten Topics (We Didn't Cover); Try It Out For Yourself; All Your New SQL Tools

As with all Head First titles, Head First SQL sets out to engage all your senses during the learning process. Unusual diagrams, questions, exercises, and off-beat pictures are just some of the ways that the author works to grab your attention and force you down the path of learning (whether it feels like you're going down that path or not). The mixture of these techniques means that your mind doesn't really have a chance to drift off and start thinking about what you're going to have for dinner. It's this style that makes the Head First series the first one I'll recommend to people setting out to learn a new skill.

For those who are wondering, Head First SQL uses the free MySQL package for all the examples and exercises. It's not necessary to have some expensive relational database system already installed on your PC. So even if your SQL learning efforts are self-funded, the total outlay will pretty much be the cost of the book, and that's it. And given that SQL is a standard query language, much of what you learn will also transfer over to any other relational database system you end up using down the road, like Oracle or DB2.

Since I've done some SQL in the past, I found most of the value for myself located in the later chapters. Working with subqueries and more complex joins aren't things I do on a regular basis, so it's easy for me to forget the concepts. But a quick flip here, and it all starts coming back, much clearer than before.

There's a reason I rarely loan out my Head First titles... they often don't come back. This will be added to that lock-and-key section of my bookshelf that requires DNA samples before they leave the premises. :)

Although I have used SQL for several years, I've used it more as someone accessing and updating data from already existing databases. I read this book to see if there were some new things I could learn, especially about creating tables as many intro SQL books are light in this area. To my surprise I also learned a few things in areas I thought I already knew well. The book is surprisingly thorough for an introductory book.

The true strength of the Head First series is the friendly and clear explanations supported with good examples and exercises. All the other stuff they tout such as their quirky humor, vintage photos, fireside chats, etc. do not do much for me and my memory plus is it getting heavily reused to the point that I ignore a lot of it. Case in point is that I can no longer remember much of the stuff I read in the Servlets Head First book since I haven't been applying it. But at least I can always go back to the book and read the clear explanations.

Although I think this book is the best intro to SQL book, I did have a few minor issues with it. One, there are a few typos and errors in the book. The good news is that none of them are major enough to lead you the wrong direction and should be mentally correctable if you pay attention. Two, I don't seem to like toy examples such as the clown tracking examples. I prefer more realistic examples such as the one dealing with personal contacts database used more extensively.

I've read two other popular intro SQL books over the years, and this is clearly (by a far margin) the best book despite my minor complaints. Well done!

I can create a database now. Prior to reading 'Head First SQL', I didn't know anything about databases. Now, I can create them, work with them, and I understand what I am doing and why I am doing it.

While I agree that to the discerning eye some of the presentation style may seem a tad 'Sesame Street', 'Sesame Street' did teach me the alphabet, thanks 'Big Bird', and how to count, 'Lady bugs twelve ... at the lady bug picnic...'. You can't argue with results.

I had never read anything prior to 'Head First SQL' on databases, so I can't compare this book to any other SQL books.

It's been a week since I finished the book and I am now responding with confidence to those requests that come through my email looking for someone who knows SQL. Thank you 'Head First'.

I'd like to give the book 5 stars but I can only give 4 because of the errors. They really put me off. I agree that one more edit of the final manuscript was in order before printing. Check out the forums on the 'Head First' website to evaluate for yourself.

'Head First SQL' is a book for beginners and for those needing a better understanding of the fundamentals of relational databases.

My first Head First book was Head First HTML with CSS & XHTML, and it was absolutely wonderful. Given that, I had very high hopes for Head First SQL as well, but I'm sad to say this book is very disappointing.

I have two main complaints: the explanations in the book, and the typos. First off, I already studied a little SQL on my own a few months ago, mainly using websites and online tutorials. It's a fairly easy language to learn so I got pretty deep into it. I think it is for that reason only that I am able to follow along so well in Head First SQL. What I mean is, it seems to me that very little explanation is actually going on in the book. I understand the Head First method of teaching, but that doesn't have to preclude *any* kind of explanation at all.

For the most part, the chapters in this book describe a bunch of different situations (Greg and his list of contacts, clowns traveling around town, donuts at different shops, etc.) and through these examples we are given a bunch of SQL queries. The problem is that only once or twice does the author actually stop to say "Ok, here is the structure of the SQL query we will use"...instead, she just throws a bunch of queries at us and I feel like I would be very lost if I hadn't already studied SQL a little bit previously.

Instead of saying something like "You type the SELECT keyword, followed by your table name, followed by....." she just gives us the statement fully written. The problem I see with this is that it doesn't teach us how to construct our own. Our only real option is to pattern our own queries based on this single example she gives, rather than to know how to compose our queries from the ground up. (Sort of the whole teach a man to fish metaphor.)

And as I mentioned, there are a ton of different examples she uses (contacts, clowns, donuts, movies, girl scouts, etc. etc.) that there is no consistency between the examples. Very early on we are encouraged to enter a bunch of data into our own SQL database on our computer, and you figure, Ok, we'll use this throughout the book to run tests on it. Nope, you'll hardly see this table again for a long time, so don't bother. What I liked about the HTML book was that the authors carried a project all the way through the book. Head First SQL does not have that consistency.

Finally, the typos in this book are atrocious. There are a lot of little typos in grammar, which are annoying and unprofessional, but forgivable because we all know well enough what was meant (e.g. "then then you type"...well, we all know that one of those "then"s isn't meant to be there). But what is worse and less forgivable are all the technical typos that actually make the examples and crossword puzzles wrong and non-workable. This is ridiculous.

There is a "thank you" in the beginning of the book that says without a certain editor's help, the book would have come out in 2008. After reading most of this book already, I truly believe it still wasn't ready to come and could have used a lot more proofreading. If I spot these errors just by my casual reading, then why can't the author and editors, whose job it is?

Something tells me that this book was rushed to be released in 2007, and it shows in the quality.

This book satisfies my need for an easy-to-learn and fun-to-read SQL tutorial. I have covered more than half of it during my daily train commute in 2 weeks after it arrived.

This book takes a not-too-difficult but oh-so-dry subject and actually makes it interesting. The Head First series has tackled subjects in a similar fashion - Java, HTML, and design patterns, for example. However, being the geek that I am I actually find these subjects interesting, but just needed some books where I could brush up quickly and easily. The subject of databases and SQL, however, is a subject where the reading material can easily made into a cure for insomnia. Not so in this case. The author gets this problem. In fact chapter one actually has as a goal "How do you trick your brain into thinking that your life actually depends on SQL?". The book is not just about writing new databases, but about maintaining and changing old ones. It also talks about working with multiple tables and how to connect those tables with diagrams that will stick with you. It shows you how to do this in a manner that is interesting with the series' usual crossword puzzles, fake interviews and conversations, and Q&A sessions. Even if you think you know SQL, I can't think of a better book for brushing up if you've been away from the subject for awhile. This is true not only because the book covers all of the basics and even some more advanced topics, but because if you need to get up to speed in a short period of time this is one of the few books on the subject that will not put you to sleep.

I should probably mention up front that I am not really a member of the demographic that this book was written for (that being the fairly new students to relational database theory), but I liked this book nonetheless. What really endears the book to me, and in fact, the entire Head First series, is the geek humor that the author sprinkles liberally throughout the book. Wordplay, funny photo captions, and entertaining exercises abound to make sure that the difficult task of teaching something as dry as an introduction to SQL is as enjoyable and down-right entertaining as possible.

If you are familiar with other books in the Head First series, then you pretty much know what you are in for with this book. If you are not familiar with this series (and honestly, if not then why aren't you?) then you are in for somewhat of a different experience than your typical beginner level technical book. For starters, the book uses lots of visuals and graphics to explain things. If the topic is learning how a select statement works, then the author hits you with building a dating service to illustrate the points. If the difference between sub-selects and outer joins is the topic, then the author drags both out onto the metaphorical stage to have a debate over why you should use one or the other. All of these implements, from outlandish scenarios to anthropomorphic database constructs are cleverly woven together to make sure that the information the author is presenting sticks to your grey matter. If you do the many and varied exercises in each chapter, then you really can learn this stuff and have a fun time doing it.
The book doesn't assume that you have had any real experience with databases and it even has a chapter explaining why you would want to use a database in the first place. The content of the book also stays away from any database -specific information and sticks to generic SQL commonalities: selects, alter tables, updates, deletes, where-clauses, joins, sub-selects, aggregate functions, ordering, etc. Constraints, views, and some rudimentary security concerns are touched on, but not to any great degree.

The appendices are really a collection of esoteric topics that he author
calls `left-overs'. There is a quick section on PHP (which seems a little out of place in such a general SQL programming book), GUI tools for databases, a list of reserved words, some additional information on data types, etc. There is a larger section for how to download and install a MySQL database, which is as close as the book comes to endorsing one database vendor.

As with most books, there are a few minor things that bothered me about this book in particular, and about the Head First series as a whole. For starters, the pictures and glyphs that the book uses get somewhat redundant after the first few times that you see them. Chapter after chapter, you see the same actors in the same or slightly different poses. In many cases, the only difference seems to be the text in the dialog bubbles that are attached to the portraits. I joked with a colleague of mine that we should have a caption contest and write our own dialog for a good number of the examples in the book. This seems to be a systemic problem with the series itself rather than a problem with Head First SQL exclusively, because I own a number of the other books in the series and they also use many of the same graphics and photos and actors in those books. Perhaps, just perhaps, it is a fiendishly devised mnemonic device to see the same images time and time again, but it strikes me as a tad redundant and a little boring after seeing the same images used to explain different topics.

In the final analysis of the book, I have to recommend this book to anyone who may be just starting out on learning SQL programming. Don't expect this book to be the last book you will need to purchase on the subject if you are aiming to be a DBA, or even an enterprise developer, but it should definitely be the first one you buy.

This book, like the others in the series, is an impressive piece of work. SQL can be pretty dry, so spicing it up in using the Head First motif definitely pays off.
Even though I gave it 5 stars, I sometimes thought too many pages were spent (wasted?) injecting humor into the learning process. Simply stating facts is not necessarily a bad way to teach soemthing. O'Reilly's "Learning SQL" by Alan Beaulieu goes that route and does a wonderful job explaining SQL - and in far fewer pages. (Granted, Head First pages are anything but dense, so total page count can be misleading.)
My only other gripe is that indexing - which I consider to be pretty darn important - was relegated to 1/2 page of text in the "Leftovers" section.

As a beginning/intermediate Ruby/Rails programmer I have been waiting for this book to fill in that big SQL hole in my knowledge base.

Even though Rails abstracts much of the underlying SQL code through its ORM, Head First SQL answers many questions I had about SQL in an entertaining way.

Before this book my SQL knowledge could be summed up in two lines.
mysqladmin -uroot create abc_development
and
localhost/phpmyadmin

During a 24 hour marathon session with lots of Red Bull and Coffee the book has switched on the big SQL light in my head now.

For this Ruby/Rails programmer chapter 7 on Multi-Table Database Design, and chapter 12 on Security was worth the price of admission alone.

The Author's implementation of the Head First style is entertaining enough to actually make Head First SQL an enjoyable thing to study rather than sitting on my shelf with the other 3 SQL books that I was hoping to learn through osmosis as they can be a bit dry.

Any book on SQL whose style and content makes it possible for me to read and reread in the last 24 hours deserves 5 Stars.

As a beginning/intermediate Ruby/Rails programmer I have been waiting for this book to fill in that big SQL hole in my knowledge base.

Even though Rails abstracts much of the underlying SQL code through its ORM, Head First SQL answers many questions I had about SQL in an entertaining way.

Before this book my SQL knowledge could be summed up in two lines.
mysqladmin -uroot create abc_development
and
localhost/phpmyadmin

During a 24 hour marathon session with lots of Red Bull and Coffee the book has switched on the big SQL light in my head now.

For this Ruby/Rails programmer chapter 7 on Multi-Table Database Design, and chapter 12 on Security was worth the price of admission alone.

The Author's implementation of the Head First style is entertaining enough to actually make Head First SQL an enjoyable thing to study rather than sitting on my shelf with the other 3 SQL books that I was hoping to learn through osmosis as they can be a bit dry.

Any book on SQL whose style and content makes it possible for me to read and reread in the last 24 hours deserves 5 Stars.

Before i review this book i would say this book for beginners only.

this book is strongly start learning for the Structures Query Language , if you use any Database management system such as Microsoft SQL server,Oracle,Mysql,Microsoft Access,or any other ,this book is compatible with you .
the book contains these chapters :

Chapter 1-data and tables .
Chapter 2-The SELECT Statement.
Chapter 3-DELETE and UPDATE.
Chapter 4-smart table design.
Chapter 5-ALTER.
Chapter 6-Advanced select.
Chapter 7-Multi-table database design.
Chapter 8-joins and multi-tables operations .
Chapter 9-sub queries.
Chapter 10-Outer Joins, self joins, and unions.
Chapter 11-Constraints, views, and Transactions.
Chapter 12-security.

Before i review this book i would say this book for beginners only.

this book is strongly start learning for the Structures Query Language , if you use any Database management system such as Microsoft SQL server,Oracle,Mysql,Microsoft Access,or any other ,this book is compatible with you .
the book contains these chapters :

Chapter 1-data and tables .
Chapter 2-The SELECT Statement.
Chapter 3-DELETE and UPDATE.
Chapter 4-smart table design.
Chapter 5-ALTER.
Chapter 6-Advanced select.
Chapter 7-Multi-table database design.
Chapter 8-joins and multi-tables operations .
Chapter 9-sub queries.
Chapter 10-Outer Joins, self joins, and unions.
Chapter 11-Constraints, views, and Transactions.
Chapter 12-security.