Customer Reviews

Essential SQLAlchemy

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

 

 

Essential SQLAlchemy by Rick Copeland is a great book describing how to use SQLAlchemy to connect Python programs to databases. In fact, at the moment (mid-summer 2008), it is the book, since there are no other books on the subject, yet. Athough I am not (yet) a SQLAlchemy user, this book seems to cover all of the core topics in SQLAlchemy. The text includes many straightforward examples of how to use various facilities in SQLAlchemy and how to map various database programming problems into Python code via SQLAlchemy. Copeland also provides a whirlwind tour of some extensions to SQLAlchemy.

To be honest, the first chapter (the proverbial introduction) almost turned me off. The author starts out slowly enough, but then he starts touching on a huge number details, which were glazing my eyes over. However, the second chapter (getting started) started back at ground zero and stepped through everything in a nice clear fashion, and the rest of the book continued in that vein. He covers all the topics you would expect in a database programming book: queries, updates, joins, the built-in types, and how to hook in to provide support for your own types.

Something I didn't realize about SQLAlchemy coming into this is that SQLAlchemy is both an ORM (what I expected) as well as a high-level, database-independent API. Which is to say, you can just access the database as tables, columns and rows rather than as classes, attributes, and object instances. Although I'd personally prefer to use the ORM, I can imagine cases where it might not be the right tool for the job, and it's good to have a choice.

I was also surprised to see the ORM supports two styles of object-relational access: the data mapper pattern (which I had seen in Django and Hibernate) and the active record (used in Ruby). The author does a good job of explaining both of these and how to use them. He even devotes a whole chapter to Exlir, which is an extension that implements the active record pattern.

In conclusion, Essential SQLAlchemy provides a thorough presentation of the SQLAlchemy tool for interfacing Python code to SQL databases. The author covers a number of different methods in which SQLAlchemy can be used to access databases from Python, and he provides plenty of details of the various APIs available to the programmer.

The SQLAlchemy project docs and this book all suffer from a common problem: 0 to database connection is more complex than expected. The quick start story just isn't there. Django/Rails got us used to a blog in 15mins and SQLAlchemy isn't like that.

The first few chapters are the weakest point. Their is a lot of code that introduces a lot of moving parts with very little explanation. The first chapter tries to do too much and introduce all the components. This is tantamount to sticking the whole book in the first 15 pages which results in confusion. This is a failing of the book.

As the detail topical coverage begins the book continues to falter; however, this could be the nature of the code it covers. The "get going" chapter involves metadata, engines, sessions, etc all of which can be handled in different ways and are discussed in "we'll come back to it" detail. This is also confusing. However, I think you just need to know a lot before you can do anything interesting and the book is in an (understandable) rush to get to something interesting. It may have been better to introduce these as a black box and come back to it at the end.

Once a connection is up and running the book nicely deconstruction the API and gradual progression from known to unknown through the SQL Expression Layer and then ORM. The final chapters on Elixir and SqlSoup were a much appreciated addition.

From a general content standpoint I'd say the code samples are strong and do a good job of showing SQLAlchemy off. The prose are not as strong. The book rarely goes beyond "this is what X is and how to use it." I would have preferred a more structured discussion of when to do what and the implications of doing so. With these limitations I'd say plan to read this sitting at a computer and working with each code sample in the REPL.

Overall this book does a good job. It is a step up from the online docs which are extensive but have an unfavorable knowledge / word ratio and lack a good tutorial framework. The down side, as compared to the online docs, is that this book is 2+ years old and it is starting to show. Hopefully an updated edition is in the works.

Bottom Line: Worth the money.

Advanced programming collections will relish Rick Copeland's ESSENTIAL SQLALCHEMY, a powerful survey for Python developers who need to access relational databases. From customizing routines and creating objects to building a mapper and providing an active record pattern, this survey of SQLAlchemy will delight patrons of advanced developer guides.