cassandra 0.4 → 0.5

data/CHANGELOG

@@ -1,4 +1,6 @@
 
+v0.5. More API changes. Working temporal comparators.
+
 v0.4. Use new comparator API. Namespace Thrift bindings; rename gem and class to Cassandra. Make tokens and limits actually work. Retry UnavailableExceptions.
 
 v0.3. Use new Thrift API.

data/Manifest

@@ -4,23 +4,23 @@ conf/log4j.properties
 conf/storage-conf.xml
 lib/cassandra/array.rb
 lib/cassandra/cassandra.rb
+lib/cassandra/columns.rb
 lib/cassandra/comparable.rb
 lib/cassandra/constants.rb
-lib/cassandra/helper.rb
 lib/cassandra/long.rb
 lib/cassandra/ordered_hash.rb
+lib/cassandra/protocol.rb
 lib/cassandra/safe_client.rb
-lib/cassandra/serialization.rb
 lib/cassandra/time.rb
 lib/cassandra/uuid.rb
 lib/cassandra.rb
 LICENSE
 Manifest
-quickstart.sh
 Rakefile
 README
-test/cassandra_client_test.rb
+test/cassandra_test.rb
 test/comparable_types_test.rb
+test/test_helper.rb
 vendor/gen-rb/cassandra.rb
 vendor/gen-rb/cassandra_constants.rb
 vendor/gen-rb/cassandra_types.rb

data/README

@@ -1,7 +1,7 @@
 
 cassandra
 
-A client for the Cassandra distributed database.
+A Ruby client for the Cassandra distributed database. 
 
 == License
 
@@ -12,26 +12,26 @@ The public certificate for this gem is here[http://rubyforge.org/frs/download.ph
 == Features
 
 * clean encapsulation of the Thrift API
-* pluggable serialization and compression
+* compatible UUID and Long classes, for GUID generation
 * Ruby 1.9 compatibility
 
-This is an alpha release and does not yet support the full Thrift API. 
+This is an alpha release and may not yet support the full set of Cassandra features.
 
-Cassandra is a rapidly moving target, but this library should always run against the bundle available {here}[http://github.com/fauna/cassandra/raw/6546d1155b77ca7bc5ebf58bdcce79ddda36f611/vendor/cassandra.tar.bz2]. Don't expect it to work against any other version right now.
-
-The Github source repository is {here}[http://github.com/fauna/cassandra/]; patches and contributions are very welcome.
+The Github source repository is {here}[http://github.com/fauna/cassandra/]. Patches and contributions are very welcome.
 
 == Installation
 
-You need Ruby 1.8 or 1.9, and Thrift. 
-
-If you don't want to install Thrift from {source}[http://incubator.apache.org/thrift/download/], you can use {this pre-packaged gem}[http://blog.evanweaver.com/files/cassandra/thrift-0.1.0.gem]. Once you have Thrift, just run:
+You need Ruby 1.8 or 1.9. If you have those, just run:
 
   sudo gem install cassandra
   
 == Usage
 
-Require the library:
+Cassandra is a rapidly moving target. In order to get a working server, change to the checkout or gem directory, and run:
+
+  rake cassandra 
+
+Now, start IRb and require the library:
   
   require 'cassandra'
   
@@ -45,7 +45,7 @@ Insert into a column family. You can insert a Cassandra::OrderedHash, or a regul
 
 Insert into a super column family:
 
-  client.insert(:UserRelationships, "5", {"user_timeline" => {"1" => ""}})
+  client.insert(:UserRelationships, "5", {"user_timeline" => {UUID.new => "1"}})
 
 Query a super column:
 

data/Rakefile

@@ -3,11 +3,66 @@ require 'echoe'
 Echoe.new("cassandra") do |p|
   p.author = "Evan Weaver"
   p.project = "fauna"
-  p.summary = "A Ruby client for CassandraDB."
+  p.summary = "A Ruby client for the Cassandra distributed database."
   p.rubygems_version = ">= 0.8"
-  p.dependencies = ['json']
+  p.dependencies = ['json', 'thrift']
   p.ignore_pattern = /^(data|vendor\/cassandra|cassandra|vendor\/thrift)/
-  p.rdoc_pattern = /^(lib|bin|tasks|ext)|_types.rb|_constants.rb|^README|^CHANGELOG|^TODO|^LICENSE|^COPYING$/
+  p.rdoc_pattern = /^(lib|bin|tasks|ext)|^README|^CHANGELOG|^TODO|^LICENSE|^COPYING$/
   p.url = "http://blog.evanweaver.com/files/doc/fauna/cassandra/"
   p.docs_host = "blog.evanweaver.com:~/www/bax/public/files/doc/"
 end
+
+desc "Start Cassandra"
+task :cassandra => [:checkout, :patch, :build] do
+  env = "CASSANDRA_INCLUDE=#{Dir.pwd}/conf/cassandra.in.sh" unless ENV["CASSANDRA_INCLUDE"]
+  exec("env #{env} cassandra/bin/cassandra -f")
+end
+
+REVISION = "15354b4906fd654d58fe50fd01ebf95b69434ba9"
+PATCHES = [
+  "http://issues.apache.org/jira/secure/attachment/12416014/0001-CASSANDRA-356-rename-clean-up-collectColumns-methods.txt",
+  "http://issues.apache.org/jira/secure/attachment/12416073/0002-v3.patch",
+  "http://issues.apache.org/jira/secure/attachment/12416074/357-v2.patch",
+  "http://issues.apache.org/jira/secure/attachment/12416086/357-3.patch"]
+  
+task :checkout do
+  # Like a git submodule, but all in one obvious place
+  unless File.exist?("cassandra")
+    system("git clone git://git.apache.org/cassandra.git") 
+    ENV["RESET"] = "true"
+  end
+end
+
+task :patch do
+  if ENV["RESET"]
+    Dir.chdir("cassandra") do
+      system("ant clean && git fetch && git reset #{REVISION} --hard")
+      # Delete untracked files, so that the patchs can apply again
+      Array(`git status`[/Untracked files:(.*)$/m, 1].to_s.split("\n")[3..-1]).each do |file|
+        File.unlink(file.sub(/^.\s+/, "")) rescue nil
+      end
+      # Patch, with a handy commit for each one
+      PATCHES.each do |url| 
+        raise "#{url} failed" unless system("curl #{url} | patch -p1")
+        system("git commit -a -m 'Applied patch: #{url.inspect}'")
+      end
+    end
+  end
+end
+
+task :build do
+  Dir.chdir("cassandra") { system("ant") } unless File.exist?("cassandra/build")
+end
+
+task :clean do
+  Dir.chdir("cassandra") { system("ant clean") }
+end
+
+desc "Regenerate thrift bindings for Cassandra"
+task :thrift do
+  system(
+    "cd vendor &&
+    rm -rf gen-rb &&
+    thrift -gen rb ../cassandra/interface/cassandra.thrift")
+end
+

data/cassandra.gemspec

@@ -2,24 +2,24 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cassandra}
-  s.version = "0.4"
+  s.version = "0.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0.8") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan Weaver"]
   s.cert_chain = ["/Users/eweaver/p/configuration/gem_certificates/evan_weaver-original-public_cert.pem"]
-  s.date = %q{2009-07-30}
-  s.description = %q{A Ruby client for CassandraDB.}
+  s.date = %q{2009-08-18}
+  s.description = %q{A Ruby client for the Cassandra distributed database.}
   s.email = %q{}
-  s.extra_rdoc_files = ["CHANGELOG", "lib/cassandra/array.rb", "lib/cassandra/cassandra.rb", "lib/cassandra/comparable.rb", "lib/cassandra/constants.rb", "lib/cassandra/helper.rb", "lib/cassandra/long.rb", "lib/cassandra/ordered_hash.rb", "lib/cassandra/safe_client.rb", "lib/cassandra/serialization.rb", "lib/cassandra/time.rb", "lib/cassandra/uuid.rb", "lib/cassandra.rb", "LICENSE", "README", "vendor/gen-rb/cassandra_constants.rb", "vendor/gen-rb/cassandra_types.rb"]
-  s.files = ["CHANGELOG", "conf/cassandra.in.sh", "conf/log4j.properties", "conf/storage-conf.xml", "lib/cassandra/array.rb", "lib/cassandra/cassandra.rb", "lib/cassandra/comparable.rb", "lib/cassandra/constants.rb", "lib/cassandra/helper.rb", "lib/cassandra/long.rb", "lib/cassandra/ordered_hash.rb", "lib/cassandra/safe_client.rb", "lib/cassandra/serialization.rb", "lib/cassandra/time.rb", "lib/cassandra/uuid.rb", "lib/cassandra.rb", "LICENSE", "Manifest", "quickstart.sh", "Rakefile", "README", "test/cassandra_client_test.rb", "test/comparable_types_test.rb", "vendor/gen-rb/cassandra.rb", "vendor/gen-rb/cassandra_constants.rb", "vendor/gen-rb/cassandra_types.rb", "cassandra.gemspec"]
+  s.extra_rdoc_files = ["CHANGELOG", "lib/cassandra/array.rb", "lib/cassandra/cassandra.rb", "lib/cassandra/columns.rb", "lib/cassandra/comparable.rb", "lib/cassandra/constants.rb", "lib/cassandra/long.rb", "lib/cassandra/ordered_hash.rb", "lib/cassandra/protocol.rb", "lib/cassandra/safe_client.rb", "lib/cassandra/time.rb", "lib/cassandra/uuid.rb", "lib/cassandra.rb", "LICENSE", "README"]
+  s.files = ["CHANGELOG", "conf/cassandra.in.sh", "conf/log4j.properties", "conf/storage-conf.xml", "lib/cassandra/array.rb", "lib/cassandra/cassandra.rb", "lib/cassandra/columns.rb", "lib/cassandra/comparable.rb", "lib/cassandra/constants.rb", "lib/cassandra/long.rb", "lib/cassandra/ordered_hash.rb", "lib/cassandra/protocol.rb", "lib/cassandra/safe_client.rb", "lib/cassandra/time.rb", "lib/cassandra/uuid.rb", "lib/cassandra.rb", "LICENSE", "Manifest", "Rakefile", "README", "test/cassandra_test.rb", "test/comparable_types_test.rb", "test/test_helper.rb", "vendor/gen-rb/cassandra.rb", "vendor/gen-rb/cassandra_constants.rb", "vendor/gen-rb/cassandra_types.rb", "cassandra.gemspec"]
   s.homepage = %q{http://blog.evanweaver.com/files/doc/fauna/cassandra/}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Cassandra", "--main", "README"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{fauna}
   s.rubygems_version = %q{1.3.4}
   s.signing_key = %q{/Users/eweaver/p/configuration/gem_certificates/evan_weaver-original-private_key.pem}
-  s.summary = %q{A Ruby client for CassandraDB.}
-  s.test_files = ["test/cassandra_client_test.rb", "test/comparable_types_test.rb"]
+  s.summary = %q{A Ruby client for the Cassandra distributed database.}
+  s.test_files = ["test/cassandra_test.rb", "test/comparable_types_test.rb", "test/test_helper.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
@@ -27,10 +27,13 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<thrift>, [">= 0"])
     else
       s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<thrift>, [">= 0"])
     end
   else
     s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<thrift>, [">= 0"])
   end
 end

data/conf/storage-conf.xml

@@ -28,24 +28,24 @@
 
          There is an implicit table named 'system' for Cassandra internals.
     -->
-    <Tables>
-      <Table Name="Twitter">
+    <Keyspaces>
+      <Keyspace Name="Twitter">
           <KeysCachedFraction>0.01</KeysCachedFraction>
           <ColumnFamily CompareWith="UTF8Type" Name="Users" />
           <ColumnFamily CompareWith="UTF8Type" Name="UserAudits" />
-          <ColumnFamily CompareWith="UTF8Type" CompareSubcolumnsWith="UUIDType" ColumnType="Super" Name="UserRelationships" />
+          <ColumnFamily CompareWith="UTF8Type" CompareSubcolumnsWith="TimeUUIDType" ColumnType="Super" Name="UserRelationships" />
           <ColumnFamily CompareWith="UTF8Type" Name="Usernames" />
           <ColumnFamily CompareWith="UTF8Type" Name="Statuses" />
           <ColumnFamily CompareWith="UTF8Type" Name="StatusAudits" />
-          <ColumnFamily CompareWith="UTF8Type" CompareSubcolumnsWith="LongType" ColumnType="Super" Name="StatusRelationships" />  
-      </Table>
+          <ColumnFamily CompareWith="UTF8Type" CompareSubcolumnsWith="TimeUUIDType" ColumnType="Super" Name="StatusRelationships" />  
+      </Keyspace>
 
-      <Table Name="Multiblog">      
+      <Keyspace Name="Multiblog">      
         <KeysCachedFraction>0.01</KeysCachedFraction>
         <ColumnFamily CompareWith="UTF8Type" Name="Blogs"/>
         <ColumnFamily CompareWith="UTF8Type" Name="Comments"/>
-      </Table>
-    </Tables>
+      </Keyspace>
+    </Keyspaces>
 
     <!-- Partitioner: any IPartitioner may be used, including your own
          as long as it is on the classpath.  Out of the box,
@@ -71,11 +71,24 @@
          clusters with a small number of nodes. -->
     <InitialToken></InitialToken>
 
-    <!-- RackAware: Setting this to true instructs Cassandra to try and place the replicas in
-         a different rack in the same datacenter and one in a different datacenter
+	
+    <!-- EndPointSnitch: Setting this to the class that implements IEndPointSnitch
+	     which will see if two endpoints are in the same data center or on the same rack.
+         Out of the box, Cassandra provides
+         org.apache.cassandra.locator.EndPointSnitch
     -->
-    <RackAware>false</RackAware>
-
+    <EndPointSnitch>org.apache.cassandra.locator.EndPointSnitch</EndPointSnitch>
+
+    <!-- Strategy: Setting this to the class that implements IReplicaPlacementStrategy
+	     will change the way the node picker works.
+         Out of the box, Cassandra provides
+         org.apache.cassandra.locator.RackUnawareStrategy
+         org.apache.cassandra.locator.RackAwareStrategy 
+		 (place one replica in a different datacenter, and the
+         others on different racks in the same one.)
+    -->
+    <ReplicaPlacementStrategy>org.apache.cassandra.locator.RackUnawareStrategy</ReplicaPlacementStrategy>
+    
     <!-- Number of replicas of the data-->
     <ReplicationFactor>1</ReplicationFactor>
 
@@ -90,14 +103,15 @@
     <BootstrapFileDirectory>data/bootstrap</BootstrapFileDirectory>
     <StagingFileDirectory>data/staging</StagingFileDirectory>
 
-
-    <!-- Add names of hosts that are deemed contact points. Cassandra nodes use
+    <!-- Addresses of hosts that are deemed contact points. Cassandra nodes use
          this list of hosts to find each other and learn the topology of the ring.
+         You must change this if you are running multiple nodes!
     -->
     <Seeds>
         <Seed>127.0.0.1</Seed>
     </Seeds>
 
+
     <!-- Miscellaneous -->
 
     <!-- time to wait for a reply from other nodes before failing the command -->
@@ -193,5 +207,4 @@
          face of hardware failures.  The default value is ten days.
     -->
     <GCGraceSeconds>864000</GCGraceSeconds>
-
 </Storage>

data/lib/cassandra.rb

@@ -15,8 +15,8 @@ require 'cassandra/comparable'
 require 'cassandra/uuid'
 require 'cassandra/long'
 require 'cassandra/safe_client'
-require 'cassandra/serialization'
 require 'cassandra/ordered_hash'
-require 'cassandra/constants'
-require 'cassandra/helper'
+require 'cassandra/columns'
+require 'cassandra/protocol'
 require 'cassandra/cassandra'
+require 'cassandra/constants'

data/lib/cassandra/array.rb

@@ -4,5 +4,5 @@ class Array
     result = []
     each { |el| result.concat(Array(el)) }
     result
-  end
+  end  
 end

data/lib/cassandra/cassandra.rb

@@ -1,22 +1,62 @@
 
-class Cassandra
-  include Helper  
-  class AccessError < StandardError; end
+=begin rdoc
+Create a new Cassandra client instance. Accepts a keyspace name, and optional host and port.
+
+  client = Cassandra.new('twitter', '127.0.0.1', 9160)
   
-  MAX_INT = 2**31 - 1
+You can then make calls to the server via the <tt>client</tt> instance.
+ 
+  client.insert(:UserRelationships, "5", {"user_timeline" => {UUID.new => "1"}})
+  client.get(:UserRelationships, "5", "user_timeline")
   
+For read methods, valid option parameters are:
+
+<tt>:count</tt>:: How many results to return. Defaults to 100.
+<tt>:start</tt>:: Column name token at which to start iterating, inclusive. Defaults to nil, which means the first column in the collation order.
+<tt>:finish</tt>:: Column name token at which to stop iterating, inclusive. Defaults to nil, which means no boundary.
+<tt>:reversed</tt>:: Swap the direction of the collation order.
+<tt>:consistency</tt>:: The consistency level of the request. Defaults to <tt>Cassandra::Consistency::ONE</tt> (one node must respond). Other valid options are <tt>Cassandra::Consistency::ZERO</tt>, <tt>Cassandra::Consistency::QUORUM</tt>, and <tt>Cassandra::Consistency::ALL</tt>.
+
+Note that some read options have no relevance in some contexts.
+ 
+For write methods, valid option parameters are:
+ 
+<tt>:timestamp </tt>:: The transaction timestamp. Defaults to the current time in milliseconds. This is used for conflict resolution by the server; you normally never need to change it.
+<tt>:consistency</tt>:: See above.
+
+=end rdoc
+
+class Cassandra
+  include Columns
+  include Protocol
+
+  class AccessError < StandardError #:nodoc:
+  end
+
   module Consistency
     include CassandraThrift::ConsistencyLevel
-    NONE = ZERO
-    WEAK = ONE
-    STRONG = QUORUM
-    PERFECT = ALL
   end
-  
+
+  MAX_INT = 2**31 - 1
+    
+  WRITE_DEFAULTS = {    
+    :count => MAX_INT,
+    :timestamp => nil,
+    :consistency => Consistency::ONE 
+  }.freeze
+
+  READ_DEFAULTS = {
+    :count => 100, 
+    :start => nil, 
+    :finish => nil, 
+    :reversed => false, 
+    :consistency => Consistency::ONE
+  }.freeze
+
   attr_reader :keyspace, :host, :port, :serializer, :transport, :client, :schema
 
   # Instantiate a new Cassandra and open the connection.
-  def initialize(keyspace, host = '127.0.0.1', port = 9160, serializer = Cassandra::Serialization::JSON)
+  def initialize(keyspace, host = '127.0.0.1', port = 9160)
     @is_super = {}
     @column_name_class = {}
     @sub_column_name_class = {}
@@ -24,242 +64,194 @@ class Cassandra
     @keyspace = keyspace
     @host = host
     @port = port
-    @serializer = serializer
 
     @transport = Thrift::BufferedTransport.new(Thrift::Socket.new(@host, @port))
-    @transport.open    
+    @transport.open
     @client = CassandraThrift::Cassandra::SafeClient.new(
-      CassandraThrift::Cassandra::Client.new(Thrift::BinaryProtocol.new(@transport)), 
+      CassandraThrift::Cassandra::Client.new(Thrift::BinaryProtocol.new(@transport)),
       @transport)
 
-    keyspaces = @client.get_string_list_property("tables")
+    keyspaces = @client.get_string_list_property("keyspaces")
     unless keyspaces.include?(@keyspace)
       raise AccessError, "Keyspace #{@keyspace.inspect} not found. Available: #{keyspaces.inspect}"
     end
-        
-    @schema = @client.describe_table(@keyspace)    
+
+    @schema = @client.describe_keyspace(@keyspace)
   end
-    
+
   def inspect
     "#<Cassandra:#{object_id}, @keyspace=#{keyspace.inspect}, @schema={#{
       schema.map {|name, hash| ":#{name} => #{hash['type'].inspect}"}.join(', ')
-    }}, @host=#{host.inspect}, @port=#{port}, @serializer=#{serializer.name}>"
+    }}, @host=#{host.inspect}, @port=#{port}>"
   end
 
-  ## Write
-  
-  # Insert a row for a key. Pass a flat hash for a regular column family, and 
-  # a nested hash for a super column family.
-  def insert(column_family, key, hash, consistency = Consistency::WEAK, timestamp = Time.stamp)
-    column_family = column_family.to_s
-    mutation = if is_super(column_family) 
-      CassandraThrift::BatchMutationSuper.new(:key => key, :cfmap => {column_family.to_s => hash_to_super_columns(column_family, hash, timestamp)})
+### Write
+
+  # Insert a row for a key. Pass a flat hash for a regular column family, and
+  # a nested hash for a super column family. Supports the <tt>:consistency</tt>
+  # and <tt>:timestamp</tt> options.
+  def insert(column_family, key, hash, options = {})
+    column_family, _, _, options = params(column_family, [options], WRITE_DEFAULTS)
+
+    mutation = if is_super(column_family)
+      CassandraThrift::BatchMutationSuper.new(
+        :key => key, 
+        :cfmap => {column_family => 
+          hash_to_super_columns(column_family, hash, options[:timestamp] || Time.stamp)})
     else
-      CassandraThrift::BatchMutation.new(:key => key, :cfmap => {column_family.to_s => hash_to_columns(column_family, hash, timestamp)})      
+      CassandraThrift::BatchMutation.new(
+        :key => key, 
+        :cfmap => {column_family => 
+          hash_to_columns(column_family, hash, options[:timestamp] || Time.stamp)})
     end
-    # FIXME Batched operations discard the consistency argument
-    @batch ? @batch << mutation : _insert(mutation, consistency)
+    
+    args = [mutation, options[:consistency]]
+    @batch ? @batch << args : _insert(*args)
   end
-  
-  private
-  
-  def _insert(mutation, consistency = Consistency::WEAK)
-    case mutation
-    when CassandraThrift::BatchMutationSuper then @client.batch_insert_super_column(@keyspace, mutation, consistency)    
-    when CassandraThrift::BatchMutation then @client.batch_insert(@keyspace, mutation, consistency)
-    end
-  end  
-  
-  public
-  
+
   ## Delete
-  
+
   # Remove the element at the column_family:key:[column]:[sub_column]
-  # path you request.
-  def remove(column_family, key, column = nil, sub_column = nil, consistency = Consistency::WEAK, timestamp = Time.stamp)
-    column_family = column_family.to_s
-    assert_column_name_classes(column_family, column, sub_column)
-
-    column = column.to_s if column
-    sub_column = sub_column.to_s if sub_column
-    args = [column_family, key, column, sub_column, consistency, timestamp]
+  # path you request. Supports the <tt>:consistency</tt> and <tt>:timestamp</tt>
+  # options.
+  def remove(column_family, key, *columns_and_options)
+    column_family, column, sub_column, options = params(column_family, columns_and_options, WRITE_DEFAULTS)    
+    args = [column_family, key, column, sub_column, options[:consistency], options[:timestamp] || Time.stamp]
     @batch ? @batch << args : _remove(*args)
   end
-  
-  private 
-  
-  def _remove(column_family, key, column, sub_column, consistency, timestamp)
-    column_path_or_parent = if is_super(column_family)
-      CassandraThrift::ColumnPathOrParent.new(:column_family => column_family, :super_column => column, :column => sub_column)
-    else
-      CassandraThrift::ColumnPathOrParent.new(:column_family => column_family, :column => column)
-    end
-    @client.remove(@keyspace, key, column_path_or_parent, timestamp, consistency)
+
+  # Remove all rows in the column family you request. Supports options 
+  # <tt>:consistency</tt> and <tt>:timestamp</tt>.
+  # FIXME May not currently delete all records without multiple calls. Waiting 
+  # for ranged remove support in Cassandra.
+  def clear_column_family!(column_family, options = {})
+    get_range(column_family).each { |key| remove(column_family, key, options) }
   end
-   
-  public
-  
-  # Remove all rows in the column family you request.
-  def clear_column_family!(column_family)
-    # Does not support consistency argument
-    get_key_range(column_family).each do |key| 
-      remove(column_family, key)
-    end
+
+  # Remove all rows in the keyspace. Supports options <tt>:consistency</tt> and 
+  # <tt>:timestamp</tt>.
+  # FIXME May not currently delete all records without multiple calls. Waiting 
+  # for ranged remove support in Cassandra.
+  def clear_keyspace!(options = {})
+    @schema.keys.each { |column_family| clear_column_family!(column_family, options) }
   end
 
-  # Remove all rows in the keyspace
-  def clear_keyspace!
-    # Does not support consistency argument
-    @schema.keys.each do |column_family|
-      clear_column_family!(column_family)
-    end
+### Read
+
+  # Count the elements at the column_family:key:[super_column] path you
+  # request. Supports options <tt>:count</tt>, <tt>:start</tt>, <tt>:finish</tt>, 
+  # <tt>:reversed</tt>, and <tt>:consistency</tt>.
+  def count_columns(column_family, key, *columns_and_options)
+    column_family, super_column, _, options = params(column_family, columns_and_options, READ_DEFAULTS)
+    _count_columns(column_family, key, super_column, options[:consistency])
   end
-  
-  ## Read
-
-  # Count the elements at the column_family:key:[super_column] path you 
-  # request.
-  def count_columns(column_family, key, super_column = nil, consistency = Consistency::WEAK)
-    column_family = column_family.to_s
-    assert_column_name_classes(column_family, super_column)
-
-    super_column = super_column.to_s if super_column
-    @client.get_column_count(@keyspace, key, 
-      CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => super_column),
-      consistency
-    )
+
+  # Multi-key version of Cassandra#count_columns. Supports options <tt>:count</tt>,
+  # <tt>:start</tt>, <tt>:finish</tt>, <tt>:reversed</tt>, and <tt>:consistency</tt>.
+  def multi_count_columns(column_family, keys, *options)
+    OrderedHash[*keys.map { |key| [key, count_columns(column_family, key, *options)] }._flatten_once]
   end
-  
-  # Multi-key version of Cassandra#count_columns.
-  def multi_count_columns(column_family, keys, super_column = nil, consistency = Consistency::WEAK)
-    OrderedHash[*keys.map do |key|   
-      [key, count_columns(column_family, key, super_column)]
-    end._flatten_once]
-  end  
-  
+
   # Return a list of single values for the elements at the
-  # column_family:key:column[s]:[sub_columns] path you request.
-  def get_columns(column_family, key, columns, sub_columns = nil, consistency = Consistency::WEAK)
-    column_family = column_family.to_s
-    assert_column_name_classes(column_family, columns, sub_columns)
-    
-    result = if is_super(column_family) 
-      if sub_columns 
-        columns_to_hash(column_family, @client.get_slice_by_names(@keyspace, key, 
-          CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => columns), 
-          sub_columns, consistency))
-      else
-        columns_to_hash(column_family, @client.get_slice_super_by_names(@keyspace, key, column_family, columns, consistency))      
-      end
-    else
-      columns_to_hash(column_family, @client.get_slice_by_names(@keyspace, key, 
-        CassandraThrift::ColumnParent.new(:column_family => column_family), columns, consistency))
-    end    
-    sub_columns || columns.map { |name| result[name] }
+  # column_family:key:column[s]:[sub_columns] path you request. Supports the 
+  # <tt>:consistency</tt> option.
+  def get_columns(column_family, key, *columns_and_options)
+    column_family, columns, sub_columns, options = params(column_family, columns_and_options, READ_DEFAULTS)    
+    _get_columns(column_family, key, columns, sub_columns, options[:consistency])
   end
 
-  # Multi-key version of Cassandra#get_columns.
-  def multi_get_columns(column_family, keys, columns, sub_columns = nil, consistency = Consistency::WEAK)
-    OrderedHash[*keys.map do |key| 
-      [key, get_columns(column_family, key, columns, sub_columns, consistency)]
-    end._flatten_once]
+  # Multi-key version of Cassandra#get_columns. Supports the <tt>:consistency</tt> 
+  # option.
+  def multi_get_columns(column_family, keys, *options)
+    OrderedHash[*keys.map { |key| [key, get_columns(column_family, key, *options)] }._flatten_once]
   end
-        
-  # Return a hash (actually, a Cassandra::OrderedHash) or a single value 
+
+  # Return a hash (actually, a Cassandra::OrderedHash) or a single value
   # representing the element at the column_family:key:[column]:[sub_column]
-  # path you request.
-  def get(column_family, key, column = nil, sub_column = nil, limit = 100, column_range = ''..'', reversed = false, consistency = Consistency::WEAK)
-    column_family = column_family.to_s
-    assert_column_name_classes(column_family, column, sub_column)    
-    _get(column_family, key, column, sub_column, limit = 100, column_range, reversed, consistency)
+  # path you request. Supports options <tt>:count</tt>, <tt>:start</tt>, 
+  # <tt>:finish</tt>, <tt>:reversed</tt>, and <tt>:consistency</tt>.
+  def get(column_family, key, *columns_and_options)
+    column_family, column, sub_column, options = params(column_family, columns_and_options, READ_DEFAULTS)
+    _get(column_family, key, column, sub_column, options[:count], options[:start], options[:finish], options[:reversed], options[:consistency])
   rescue CassandraThrift::NotFoundException
     is_super(column_family) && !sub_column ? OrderedHash.new : nil
   end
 
-  # Multi-key version of Cassandra#get.
-  def multi_get(column_family, keys, column = nil, sub_column = nil, limit = 100, column_range = ''..'', reversed = false, consistency = Consistency::WEAK)
-    OrderedHash[*keys.map do |key| 
-      [key, get(column_family, key, column, sub_column, limit, column_range, reversed, consistency)]
-    end._flatten_once]
+  # Multi-key version of Cassandra#get. Supports options <tt>:count</tt>, 
+  # <tt>:start</tt>, <tt>:finish</tt>, <tt>:reversed</tt>, and <tt>:consistency</tt>.
+  def multi_get(column_family, keys, *options)
+    OrderedHash[*keys.map { |key| [key, get(column_family, key, *options)] }._flatten_once]
   end
-  
-  # Return true if the column_family:key:[column]:[sub_column] path you 
-  # request exists.
-  def exists?(column_family, key, column = nil, sub_column = nil, consistency = Consistency::WEAK)
-    column_family = column_family.to_s
-    assert_column_name_classes(column_family, column, sub_column)    
-    _get(column_family, key, column, sub_column, 1, ''..'', false, consistency)
+
+  # Return true if the column_family:key:[column]:[sub_column] path you
+  # request exists. Supports the <tt>:consistency</tt> option.
+  def exists?(column_family, key, *columns_and_options)
+    column_family, column, sub_column, options = params(column_family, columns_and_options, READ_DEFAULTS)    
+    _get(column_family, key, column, sub_column, 1, nil, nil, nil, options[:consistency])
     true
   rescue CassandraThrift::NotFoundException
   end
-  
-  private
-  
-  def _get(column_family, key, column = nil, sub_column = nil, limit = 100, column_range = ''..'', reversed = false, consistency = Consistency::WEAK)
-    column = column.to_s if column
-    sub_column = sub_column.to_s if sub_column    
-    # FIXME Comparable types in a are not checked
-    column_range = (column_range.begin.to_s)..(column_range.end.to_s)
-
-    # You have got to be kidding
-    if is_super(column_family)
-      if sub_column
-        # Limit and column_range parameters have no effect
-        load(@client.get_column(@keyspace, key,  
-            CassandraThrift::ColumnPath.new(:column_family => column_family, :super_column => column, :column => sub_column),
-            consistency).value)
-      elsif column
-        sub_columns_to_hash(column_family, 
-          @client.get_slice(@keyspace, key, 
-            CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => column), 
-            column_range.begin, column_range.end, !reversed, limit, consistency))
-      else
-        columns_to_hash(column_family, 
-          @client.get_slice_super(@keyspace, key, column_family, column_range.begin, column_range.end, !reversed, limit, consistency))
-      end
-    else
-      if column
-        # Limit and column_range parameters have no effect
-        load(@client.get_column(@keyspace, key, 
-          CassandraThrift::ColumnPath.new(:column_family => column_family, :column => column),
-          consistency).value)
-      else
-        columns_to_hash(column_family, 
-          @client.get_slice(@keyspace, key, 
-            CassandraThrift::ColumnParent.new(:column_family => column_family), 
-            column_range.begin, column_range.end, !reversed, limit, consistency))
-      end 
-    end
-  end
-  
-  public
-    
+
   # Return a list of keys in the column_family you request. Requires the
-  # table to be partitioned with OrderPreservingHash.
-  def get_key_range(column_family, key_range = ''..'', limit = 100, consistency = Consistency::WEAK)      
-    column_family = column_family.to_s
-    @client.get_key_range(@keyspace, column_family, key_range.begin, key_range.end, limit)
+  # table to be partitioned with OrderPreservingHash. Supports the 
+  # <tt>:count</tt>, <tt>:start</tt>, <tt>:finish</tt>, and <tt>:consistency</tt> 
+  # options.
+  def get_range(column_family, options = {})
+    column_family, _, _, options = params(column_family, [options], READ_DEFAULTS)
+    _get_range(column_family, options[:start], options[:finish], options[:count], options[:consistency])
   end
-  
-  # Count all rows in the column_family you request. Requires the table 
-  # to be partitioned with OrderPreservingHash.
-  def count(column_family, key_range = ''..'', limit = MAX_INT, consistency = Consistency::WEAK)
-    get_key_range(column_family, key_range, limit, consistency).size
+
+  # Count all rows in the column_family you request. Requires the table
+  # to be partitioned with OrderPreservingHash. Supports the <tt>:start</tt>, 
+  # <tt>:finish</tt>, and <tt>:consistency</tt> options.
+  # FIXME will count only MAX_INT records
+  def count_range(column_family, options = {})
+    get_range(column_family, options.merge(:count => MAX_INT)).size
   end
-  
+
+  # Open a batch operation and yield. Inserts and deletes will be queued until
+  # the block closes, and then sent atomically to the server.
+  # FIXME Make deletes truly atomic.
   def batch
     @batch = []
-    yield    
-    compact_mutations!
-    dispatch_mutations!    
+    yield
+    compact_mutations
+    dispatch_mutations
     @batch = nil
   end
   
   private
+  
+  # Extract and validate options.
+  def params(column_family, args, options)
+    if args.last.is_a?(Hash)      
+      if (extras = args.last.keys - options.keys).any?
+        this = "#{self.class}##{caller[0].split('`').last[0..-2]}"
+        raise ArgumentError, "Invalid options #{extras.inspect[1..-2]} for #{this}"
+      end
+      options = options.merge(args.pop)
+    end    
 
-  def compact_mutations!
+    column_family, column, sub_column = column_family.to_s, args[0], args[1]
+    assert_column_name_classes(column_family, column, sub_column)    
+    [column_family, map_to_s(column), map_to_s(sub_column), options]
+  end
+  
+  # Convert stuff to strings.
+  def map_to_s(el)
+    case el
+    when NilClass # nil
+    when Array then el.map { |i| map_to_s(i) }
+    when Comparable, String, Symbol then el.to_s
+    else
+      raise Comparable::TypeError, "Can't map #{el.inspect}"
+    end
+  end
+  
+  # Roll up queued mutations as much as possible, to improve atomicity.
+  def compact_mutations
     compact_batch = []
-    mutations = {}   
+    mutations = {}
 
     @batch << nil # Close it
     @batch.each do |m|
@@ -269,7 +261,7 @@ class Cassandra
         compact_batch.concat(mutations.values.map {|x| x.values}.flatten)
         mutations = {}
         # Insert delete operation
-        compact_batch << m 
+        compact_batch << m
       else # BatchMutation, BatchMutationSuper
         # Do a nested hash merge
         if mutation_class = mutations[m.class]
@@ -287,29 +279,20 @@ class Cassandra
         end
       end
     end
-            
+
     @batch = compact_batch
   end
-  
-  def dispatch_mutations!
-    @batch.each do |args| 
-      case args
-      when Array 
-        _remove(*args)
-      when CassandraThrift::BatchMutationSuper, CassandraThrift::BatchMutation 
+
+  # Send all the queued mutations to the server.
+  def dispatch_mutations
+    @batch.compact!
+    @batch.each do |args|
+      case args.first
+      when CassandraThrift::BatchMutationSuper, CassandraThrift::BatchMutation
         _insert(*args)
+      else
+        _remove(*args)
       end
     end
   end  
-  
-  def dump(object)
-    # Special-case nil as the empty byte array
-    return "" if object == nil
-    @serializer.dump(object)
-  end
-  
-  def load(object)
-    return nil if object == ""  
-    @serializer.load(object)
-  end  
 end