Cassandra: The Definitive Guide [Paperback]

Eben Hewitt (Author)

Book Description

Publication Date: November 29, 2010

What could you do with data if scalability wasn't a problem? With this hands-on guide, you'll learn how Apache Cassandra handles hundreds of terabytes of data while remaining highly available across multiple data centers -- capabilities that have attracted Facebook, Twitter, and other data-intensive companies. Cassandra: The Definitive Guide provides the technical details and practical examples you need to assess this database management system and put it to work in a production environment.

Author Eben Hewitt demonstrates the advantages of Cassandra's nonrelational design, and pays special attention to data modeling. If you're a developer, DBA, application architect, or manager looking to solve a database scaling issue or future-proof your application, this guide shows you how to harness Cassandra's speed and flexibility.

• Understand the tenets of Cassandra's column-oriented structure
• Learn how to write, update, and read Cassandra data
• Discover how to add or remove nodes from the cluster as your application requires
• Examine a working application that translates from a relational model to Cassandra's data model
• Use examples for writing clients in Java, Python, and C#
• Use the JMX interface to monitor a cluster's usage, memory patterns, and more
• Tune memory settings, data storage, and caching for better performance

Editorial Reviews

About the Author

Eben Hewitt is Director of Application Architecture at a publicly traded company where he is responsible for the design of their mission-critical, global-scale web, mobile and SOA integration projects. He has written several programming books, including Java SOA Cookbook (O'Reilly).

Product Details

• Paperback: 332 pages
• Publisher: O'Reilly Media; 1 edition (November 29, 2010)
• Language: English
• ISBN-10: 1449390412
• ISBN-13: 978-1449390419
• Product Dimensions: 7.1 x 0.7 x 9.2 inches
• Shipping Weight: 1 pounds (View shipping rates and policies)
• Average Customer Review: 3.2 out of 5 stars  See all reviews (12 customer reviews)
• Amazon Best Sellers Rank: #157,263 in Books (See Top 100 in Books)
  • #70 in Books > Computers & Technology > Databases > Database Design
  • #87 in Books > Computers & Technology > Computer Science > Information Theory
  • #89 in Books > Computers & Technology > Computer Science > Modeling & Simulation

More About the Author

Eben Hewitt is the Chief Information Officer at O'Reilly Media. For nearly 15 years, he has worked in positions throughout IT, most recently on large-scale web and SOA integration projects, event-driven architecture, rules engines, distributed software, and messaging systems.

His team's architecture work for an integration with Google, Inc won the 2011 Fusion Middleware Innovation Award from Oracle Corp.

Hewitt is the author of several technical books, including Cassandra: The Definitive Guide and Java SOA Cookbook, and he is a contributor to 97 Things Every Software Architect Should Know.

He is a popular speaker at international conferences, a TOGAF certified architect, and a certified Scum Master.

Follow Eben on Twitter at @ebenhewitt or visit http://www.ebenhewitt.com.

Most Helpful Customer Reviews

55 of 57 people found the following review helpful

3.0 out of 5 stars Filled with information but not necessarily the information you want December 8, 2010

By John Armstrong

Format:Paperback

I'm not a database person but I've worked with SQL databases (esp. MySQL) and have read a few papers about non-relational databases, particularly Google's Bigtable. I understand the "web-scale" data challenge and see how a distributed, fault-tolerant, tunable open-source database like Cassandra can be an incredibly useful tool for addressing it. Therefore I was really looking forward to the publication of Eben Hewitt's Cassandra, The Definitive Guide. I was hoping that it would lay out all the important things a person would need to know in order to decide whether Cassandra made sense for their project and, if it did, how specifically they would use it.

Now that the book's out and I've had a chance to read it once through, I have to say that it does not meet my expectations. The author is clearly very interested in his subject and also very anxious to share insights not only into Cassandra but into modern non-relational databases in general (to the extent of including a 25-page appendix "The Nonrelational Landscape" at the end of the book). He does a pretty good job of explaining how Cassandra works at the level of distributed storage including scaling as well as availability and consistency. And though I haven't gone through the steps, he seems to give pretty good instructions for installing, configuring and monitoring a Cassandra cluster.

What he doesn't cover nearly as well as I was hoping (and would have expected from an O'Reilly book) is data modeling in Cassandra and the actual APIs for putting data into the database and getting data out (i.e. querying). It's not that he doesn't cover these subjects at all. In fact he devotes two chapters to data modeling (Chapter 3 The Cassandra Data Model and Chapter 4 Sample Application) and two to APIs (Chapter 7 Reading and Writing Data and Chapter 8 Clients), and these chapters contain a lot of useful information. The problem is that the information I really want is either mixed in with other, for me, less important information and/or is too limited or even not present at all.

Here are some things that I would have expected to be presented in reasonably full, coherent form in a "definitive guide" to Cassandra:

Data modeling:

Column families, supercolumns and columns - what are they for, how do you use them effectively? Especially supercolumns, which, in conjunction with the intrinsically sparse data representation, allow you to blur the distinction between structure and data and store data in "wide" format and even as out-and-out row-specific lists. He touches on matters of this sort, including in the design patterns at the end of his Data Modeling chapter, but doesn't integrate them into a coherent account of how to use the Cassandra data representation model.

Lack of joins - what are the alternatives? He addresses this issue too, but mostly says, denormalize your tables and design for common queries - or even more bluntly, precompute the results of your common queries and put them into your database. This may be a good approach in some situations, but leaves a lot of questions like, when do you precompute your query results, where and how, what triggers the computation, and how do you handle data changes that invalidate previously precomputed query results (one of the problems that normalization and joins were originally designed to solve). Also, I believe he does not say very much about implementing joins and other complex queries on the client side. Does Cassandra have properties that determine more vs. less efficient ways of doing this? How important is planning for locality in your column family organization? And supercolumns for maintaining lists/sets so that you don't have to assemble them at query time?

APIs:

Primary API - what is it? As the author explains, Cassandra doesn't have a query language, so he can't offer a chapter on the Cassandra equivalent of, say, SQL for relational databases. But Cassandra does have an API that lets you put data in and get data out, if not also other things like creating and deleting column families, supercolumns and columns. I was really expecting a chapter (or appendix or whatever) listing out the complete set of API requests and responses, either in some language-neutral format or in terms of the "native" Cassandra language, i.e. Java, ideally with additional information on "bindings" for other client-side languages like PHP, Python and so on. Again the information is sort of there, but not pulled together.

Higher-level wrappers - what are they about? The author talks about Thrift and Avro as (at least somewhat) high-level languages for communicating with Cassandra, but doesn't lay out in any coherent what those languages are. These tools may be very familiar to some, but I'm sure not to all. He does provide enough information - especially in the form of external links - to make it possible to start exploring these tools, but I would have expected the book to give a pretty good idea of what they're about without having to go off and read other material.

While I am, overall, dissatisfied with the book, I found it both an interesting read and an engaging introduction to the world of Cassandra. It also undeniably offers a wealth of information, even if it's not exactly the information a person may be looking for. For this reason I'm rating it 3 stars.

21 of 21 people found the following review helpful

2.0 out of 5 stars Disappointing: premature, lacks organization and support January 5, 2011

By Aiden Mark Humpheys

Format:Paperback

The information in this book is solid enough but its chaotic structure and lack of support for the code examples make it hard to justify a purchase.

The book was written to against version 0.7b2 of Cassandra. That beta status alone should be warning of the perils of premature publication. None of the code examples work (or indeed compile) with the current API (0.7b5). Downloading the latest code from the author's spartan support site offers little gain. The zip ball contains a readme file noting that the code did work once and suggesting the reader fixes it themselves.

There is a consistent pattern of requiring the reader to understand terms which are first defined several chapters later. Slices for example, or setting up the Cassandra JMX interface which is required for data loading in chapter 4 but first described in chapter 8.

Annoying, especially as there is solid information here and it's not badly written. Had the O'Reilly editors been more pro-active, ignored the me-first commercial pressures, delayed publication until the API stabilized and sorted out the structural problems in the writing this could have been a solid read.

6 of 7 people found the following review helpful

3.0 out of 5 stars Good guide to Cassandra itself but hampered by lack of clients August 2, 2011

By Brian Tarbox

Format:Paperback|Amazon Verified Purchase

This book is a fine introduction to Cassandra itself, and even to the whole genre of non relational databases. Where it falls down is if you want to actually start using Cassandra for an actual product. The fault doesn't lie with the book, but with the confused state of Cassandra clients. Basically no one codes directly to Cassandra: people code to one of the various Cassandra clients such as Thrift, Avro, Hector, Chirper, Pelops, etc. Cassandra has many clients none of which is the clear leader, and none of which really solve the full problem of writing to Cassandra.

Given that the only real way to learn system is to code to it this presents a real challenge. The current book will give you an overview and feel for Cassandra but will not by itself allow you to start using it.