cassandra 0.5.4 → 0.5.5

data/CHANGELOG

@@ -1,4 +1,6 @@
 
+v0.5.5. to_guid for Long. Don't continually re-checkout the Git mirror. Use curl instead of wget, sigh. Use new unified insert API.
+
 v0.5.4. Use wget instead of curl.
 
 v0.5.3. Update Multiblog sample schema.

data/Manifest

@@ -8,6 +8,7 @@ lib/cassandra/cassandra.rb
 lib/cassandra/columns.rb
 lib/cassandra/comparable.rb
 lib/cassandra/constants.rb
+lib/cassandra/debug.rb
 lib/cassandra/long.rb
 lib/cassandra/ordered_hash.rb
 lib/cassandra/protocol.rb

data/README

@@ -27,7 +27,7 @@ Cassandra itself is a rapidly moving target. In order to get a working server, u
 
   cassandra_helper cassandra
   
-A server will be installed in <tt>$HOME/cassandra/r$REVISION</tt>, and started in debug mode.
+A server will be installed in <tt>$HOME/cassandra/server</tt>, and started in debug mode.
 
 == Usage
   

data/Rakefile

@@ -16,26 +16,28 @@ unless ENV['FROM_BIN_CASSANDRA_HELPER']
   end
 end
 
-REVISION = "007df950fc9e9fad255167db74517095a8326f25"
+REVISION = "c4992f48ce9c26ce4fd028240447b4cbe85ecf26"
 
 PATCHES = [
-  "http://issues.apache.org/jira/secure/attachment/12417025/CASSANDRA-377.diff"]
+  "http://issues.apache.org/jira/secure/attachment/12417533/388.patch",
+  "http://issues.apache.org/jira/secure/attachment/12417682/CASSANDRA-336-code.diff",
+  "http://issues.apache.org/jira/secure/attachment/12417683/CASSANDRA-336-thrift.diff"]
 
-CASSANDRA_HOME = "#{ENV['HOME']}/cassandra/r#{REVISION[0, 8]}"
+CASSANDRA_HOME = "#{ENV['HOME']}/cassandra/server"
 
 CASSANDRA_TEST = "#{ENV['HOME']}/cassandra/test"
 
+directory CASSANDRA_TEST
+
 desc "Start Cassandra"
-task :cassandra => [:java, :checkout, :patch, :build] do
+task :cassandra => [:build, CASSANDRA_TEST] do
   # Construct environment
   env = ""
   if !ENV["CASSANDRA_INCLUDE"]
     env << "CASSANDRA_INCLUDE=#{Dir.pwd}/conf/cassandra.in.sh "
     env << "CASSANDRA_HOME=#{CASSANDRA_HOME} "
-    env << "CASSANDRA_CONF=#{File.expand_path(File.dirname(__FILE__))}/conf" 
-  end  
-  # Create data dir
-  Dir.mkdir(CASSANDRA_TEST) if !File.exist?(CASSANDRA_TEST)
+    env << "CASSANDRA_CONF=#{File.expand_path(File.dirname(__FILE__))}/conf"
+  end
   # Start server
   Dir.chdir(CASSANDRA_TEST) do
     exec("env #{env} #{CASSANDRA_HOME}/bin/cassandra -f")
@@ -53,29 +55,35 @@ task :java do
   end
 end
 
-desc "Checkout Cassandra from git"
-task :checkout do
-  # Check git version
+desc "Check Git version"
+task :git do
   unless `git --version 2>&1` =~ /git version 1.6/
     puts "You need to install git 1.6."
     exit(1)
   end
+end
+
+desc "Checkout Cassandra from git"
+task :checkout => [:java, :git] do
   # Like a git submodule, but all in one more obvious place
   unless File.exist?(CASSANDRA_HOME)
+    puts "Checking Cassandra out from git"
     cmd = "git clone git://git.apache.org/cassandra.git #{CASSANDRA_HOME}"
     if !system(cmd)
       put "Checkout failed. Try:\n  #{cmd}"
       exit(1)
     end
-    ENV["RESET"] = "true"
-  end
+  end  
 end
 
 desc "Apply patches to Cassandra checkout; use RESET=1 to force"
-task :patch do
-  if ENV["RESET"]
-    system("rm -rf #{CASSANDRA_TEST}/data")
-    Dir.chdir(CASSANDRA_HOME) do
+task :patch => [:checkout] do
+  # Verify checkout revision and patchset
+  Dir.chdir(CASSANDRA_HOME) do  
+    current_checkout = `git show HEAD~#{PATCHES.size} | head -n1`
+    if !current_checkout.include?(REVISION)
+      puts "Updating Cassandra and applying patches"
+      system("rm -rf #{CASSANDRA_TEST}/data")
       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|
@@ -83,7 +91,7 @@ task :patch do
       end
       # Patch, with a handy commit for each one
       PATCHES.each do |url|
-        raise "#{url} failed" unless system("wget -O - #{url} | patch -p1")
+        raise "#{url} failed" unless system("curl #{url} | patch -p1")
         system("git commit -a -m 'Applied patch: #{url.inspect}'")
       end
     end
@@ -91,8 +99,9 @@ task :patch do
 end
 
 desc "Rebuild Cassandra"
-task :build do
+task :build => [:patch] do
   unless File.exist?("#{CASSANDRA_HOME}/build")
+    puts "Building Cassandra"
     cmd = "cd #{CASSANDRA_HOME} && ant"
     if !system(cmd)
       puts "Could not build Casssandra. Try:\n  #{cmd}"
@@ -103,25 +112,27 @@ end
 
 desc "Clean Cassandra build"
 task :clean do
+  puts "Cleaning Cassandra"
   if File.exist?(CASSANDRA_HOME)
     Dir.chdir(CASSANDRA_HOME) do
       system("ant clean")
     end
-  end      
+  end
 end
 
 namespace :data do
   desc "Reset test data"
   task :reset do
+    puts "Resetting test data"
     system("rm -rf #{CASSANDRA_TEST}/data")
   end
 end
 
 # desc "Regenerate thrift bindings for Cassandra" # Dev only
 task :thrift do
+  puts "Generating Thrift bindings"
   system(
     "cd vendor &&
     rm -rf gen-rb &&
     thrift -gen rb #{CASSANDRA_HOME}/interface/cassandra.thrift")
 end
-

data/cassandra.gemspec

@@ -2,18 +2,18 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cassandra}
-  s.version = "0.5.4"
+  s.version = "0.5.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-08-19}
+  s.date = %q{2009-08-27}
   s.default_executable = %q{cassandra_helper}
   s.description = %q{A Ruby client for the Cassandra distributed database.}
   s.email = %q{}
   s.executables = ["cassandra_helper"]
-  s.extra_rdoc_files = ["bin/cassandra_helper", "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 = ["bin/cassandra_helper", "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.extra_rdoc_files = ["bin/cassandra_helper", "CHANGELOG", "lib/cassandra/array.rb", "lib/cassandra/cassandra.rb", "lib/cassandra/columns.rb", "lib/cassandra/comparable.rb", "lib/cassandra/constants.rb", "lib/cassandra/debug.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 = ["bin/cassandra_helper", "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/debug.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"]

data/conf/storage-conf.xml

@@ -45,6 +45,12 @@
         <ColumnFamily CompareWith="TimeUUIDType" Name="Blogs"/>
         <ColumnFamily CompareWith="TimeUUIDType" Name="Comments"/>
       </Keyspace>
+
+      <Keyspace Name="MultiblogLong">      
+        <KeysCachedFraction>0.01</KeysCachedFraction>
+        <ColumnFamily CompareWith="LongType" Name="Blogs"/>
+        <ColumnFamily CompareWith="LongType" Name="Comments"/>
+      </Keyspace>
     </Keyspaces>
 
     <!-- Partitioner: any IPartitioner may be used, including your own

data/lib/cassandra.rb

@@ -20,3 +20,4 @@ require 'cassandra/columns'
 require 'cassandra/protocol'
 require 'cassandra/cassandra'
 require 'cassandra/constants'
+require 'cassandra/debug' if ENV['DEBUG']

data/lib/cassandra/cassandra.rb

@@ -3,12 +3,12 @@
 Create a new Cassandra client instance. Accepts a keyspace name, and optional host and port.
 
   client = Cassandra.new('twitter', '127.0.0.1', 9160)
-  
+
 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.
@@ -18,9 +18,9 @@ For read methods, valid option parameters are:
 <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.
 
@@ -38,18 +38,18 @@ class Cassandra
   end
 
   MAX_INT = 2**31 - 1
-    
-  WRITE_DEFAULTS = {    
+
+  WRITE_DEFAULTS = {
     :count => MAX_INT,
     :timestamp => nil,
-    :consistency => Consistency::ONE 
+    :consistency => Consistency::ONE
   }.freeze
 
   READ_DEFAULTS = {
-    :count => 100, 
-    :start => nil, 
-    :finish => nil, 
-    :reversed => false, 
+    :count => 100,
+    :start => nil,
+    :finish => nil,
+    :reversed => false,
     :consistency => Consistency::ONE
   }.freeze
 
@@ -91,46 +91,49 @@ class Cassandra
   # 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)
+    column_family, _, _, options = 
+      validate_params(column_family, key, [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 => 
-          hash_to_columns(column_family, hash, options[:timestamp] || Time.stamp)})
-    end
-    
-    args = [mutation, options[:consistency]]
-    @batch ? @batch << args : _insert(*args)
+    args = [column_family, hash, options[:timestamp] || Time.stamp]
+    columns = is_super(column_family) ? hash_to_super_columns(*args) : hash_to_columns(*args)
+    mutation = CassandraThrift::BatchMutation.new(
+      :key => key,
+      :cfmap => {column_family => columns},
+      :column_paths => [])
+
+    @batch ? @batch << mutation : _mutate([mutation], options[:consistency])
   end
 
   ## Delete
 
-  # Remove the element at the column_family:key:[column]:[sub_column]
+  # _mutate the element at the column_family:key:[column]:[sub_column]
   # 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)
+    column_family, column, sub_column, options = 
+      validate_params(column_family, key, columns_and_options, WRITE_DEFAULTS)
+
+    args = {:column_family => column_family, :timestamp => options[:timestamp] || Time.stamp}
+    columns = is_super(column_family) ? {:super_column => column, :column => sub_column} : {:column => column}
+    mutation = CassandraThrift::BatchMutation.new(
+      :key => key,
+      :cfmap => {},
+      :column_paths => [CassandraThrift::ColumnPath.new(args.merge(columns))])
+
+    @batch ? @batch << mutation : _mutate([mutation], options[:consistency])
   end
 
-  # Remove all rows in the column family you request. Supports options 
+  # 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 
+  # 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
 
-  # Remove all rows in the keyspace. Supports options <tt>:consistency</tt> and 
+  # 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 
+  # 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) }
@@ -139,10 +142,11 @@ class Cassandra
 ### 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>, 
+  # 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)
+    column_family, super_column, _, options = 
+      validate_params(column_family, key, columns_and_options, READ_DEFAULTS)      
     _count_columns(column_family, key, super_column, options[:consistency])
   end
 
@@ -153,14 +157,15 @@ class Cassandra
   end
 
   # Return a list of single values for the elements at the
-  # column_family:key:column[s]:[sub_columns] path you request. Supports the 
+  # 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)    
+    column_family, columns, sub_columns, options = 
+      validate_params(column_family, key, columns_and_options, READ_DEFAULTS)      
     _get_columns(column_family, key, columns, sub_columns, options[:consistency])
   end
 
-  # Multi-key version of Cassandra#get_columns. Supports the <tt>:consistency</tt> 
+  # 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]
@@ -168,16 +173,17 @@ class Cassandra
 
   # 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. Supports options <tt>:count</tt>, <tt>:start</tt>, 
+  # 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)
+    column_family, column, sub_column, options = 
+      validate_params(column_family, key, 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. Supports options <tt>:count</tt>, 
+  # 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]
@@ -186,23 +192,25 @@ class Cassandra
   # 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)    
+    column_family, column, sub_column, options = 
+      validate_params(column_family, key, columns_and_options, READ_DEFAULTS)
     _get(column_family, key, column, sub_column, 1, nil, nil, nil, options[:consistency])
     true
   rescue CassandraThrift::NotFoundException
   end
 
   # Return a list of keys in the column_family you request. Requires the
-  # table to be partitioned with OrderPreservingHash. Supports the 
-  # <tt>:count</tt>, <tt>:start</tt>, <tt>:finish</tt>, and <tt>:consistency</tt> 
+  # 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)
+    column_family, _, _, options = 
+      validate_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. Supports the <tt>:start</tt>, 
+  # 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 = {})
@@ -210,33 +218,42 @@ class Cassandra
   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
+  # the block closes, and then sent atomically to the server.  Supports the
+  # <tt>:consistency</tt> option, which overrides the consistency set in
+  # the individual commands.
+  def batch(options = {})
+    _, _, _, options = 
+      validate_params(@schema.keys.first, "", [options], WRITE_DEFAULTS)
+
     @batch = []
     yield
-    compact_mutations
-    dispatch_mutations
+    compact_mutations!
+    _mutate(@batch, options[:consistency])
     @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
+  # FIXME Should be done as a decorator
+  def validate_params(column_family, key, args, options)
+    if !key.is_a?(String)
+      raise ArgumentError, "Key #{key.inspect} must be a String for #{calling_method}"
+    elsif args.last.is_a?(Hash)
+      extras = args.last.keys - options.keys
+      raise ArgumentError, "Invalid options #{extras.inspect[1..-2]} for #{calling_method}" if extras.any?
       options = options.merge(args.pop)
-    end    
+    end
 
     column_family, column, sub_column = column_family.to_s, args[0], args[1]
-    assert_column_name_classes(column_family, column, sub_column)    
+    assert_column_name_classes(column_family, column, sub_column)
     [column_family, map_to_s(column), map_to_s(sub_column), options]
   end
   
+  def calling_method
+     "#{self.class}##{caller[0].split('`').last[0..-3]}"
+  end
+
   # Convert stuff to strings.
   def map_to_s(el)
     case el
@@ -247,52 +264,28 @@ class Cassandra
       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 = []
+
+  # Roll up queued mutations, to improve atomicity.
+  def compact_mutations!
     mutations = {}
 
-    @batch << nil # Close it
+    # Nested hash merge
     @batch.each do |m|
-      case m
-      when Array, nil
-        # Flush compacted mutations
-        compact_batch.concat(mutations.values.map {|x| x.values}.flatten)
-        mutations = {}
-        # Insert delete operation
-        compact_batch << m
-      else # BatchMutation, BatchMutationSuper
-        # Do a nested hash merge
-        if mutation_class = mutations[m.class]
-          if mutation = mutation_class[m.key]
-            if columns = mutation.cfmap[m.cfmap.keys.first]
-              columns.concat(m.cfmap.values.first)
-            else
-              mutation.cfmap.merge!(m.cfmap)
-            end
-          else
-            mutation_class[m.key] = m
-          end
+      if mutation = mutations[m.key]
+        # Inserts
+        if columns = mutation.cfmap[m.cfmap.keys.first]
+          columns.concat(m.cfmap.values.first)
         else
-          mutations[m.class] = {m.key => m}
+          mutation.cfmap.merge!(m.cfmap)
         end
+        # Deletes
+        mutation.column_paths.concat(m.column_paths)
+      else
+        mutations[m.key] = m
       end
     end
 
-    @batch = compact_batch
+    # FIXME Return atomic thrift thingy
+    @batch = mutations.values
   end
-
-  # 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  
 end

data/lib/cassandra/columns.rb

@@ -63,23 +63,24 @@ class Cassandra
       end
       hash    
     end
-    
+        
     def hash_to_columns(column_family, hash, timestamp)
       assert_column_name_classes(column_family, hash.keys)
-      hash_to_columns_without_assertion(column_family, hash, timestamp)
-    end
-    
-    def hash_to_columns_without_assertion(column_family, hash, timestamp)
       hash.map do |column, value|
-        CassandraThrift::Column.new(:name => column.to_s, :value => value, :timestamp => timestamp)
+        CassandraThrift::ColumnOrSuperColumn.new(:column => 
+          CassandraThrift::Column.new(:name => column.to_s, :value => value, :timestamp => timestamp))
       end    
-    end    
+    end
     
     def hash_to_super_columns(column_family, hash, timestamp)
       assert_column_name_classes(column_family, hash.keys)      
       hash.map do |column, sub_hash|
         assert_column_name_classes(column_family, nil, sub_hash.keys)
-        CassandraThrift::SuperColumn.new(:name => column.to_s, :columns => hash_to_columns_without_assertion(column_family, sub_hash, timestamp))
+        sub_columns = sub_hash.map do |sub_column, value|
+          CassandraThrift::Column.new(:name => sub_column.to_s, :value => value, :timestamp => timestamp)
+        end    
+        CassandraThrift::ColumnOrSuperColumn.new(:super_column => 
+          CassandraThrift::SuperColumn.new(:name => column.to_s, :columns => sub_columns))
       end
     end    
   end

data/lib/cassandra/debug.rb

@@ -0,0 +1,7 @@
+
+class CassandraThrift::Cassandra::Client
+  def send_message(*args)
+    pp args
+    super
+  end
+end

data/lib/cassandra/long.rb

@@ -2,18 +2,26 @@
 class Cassandra
   # A temporally-ordered Long class for use in Cassandra column names
   class Long < Comparable
-  
-    def initialize(bytes = nil)      
+
+    def initialize(bytes = nil)
       case bytes
       when String
-        raise TypeError, "8 bytes required" if bytes.size != 8
-        @bytes = bytes
+        case bytes.size
+        when 8 # Raw byte array
+          @bytes = bytes
+        when 18 # Human-readable UUID-like representation; inverse of #to_guid
+          elements = bytes.split("-")
+          raise TypeError, "Malformed UUID-like representation" if elements.size != 3
+          @bytes = elements.join.to_a.pack('H32')
+        else
+          raise TypeError, "8 bytes required for byte array, or 18 characters required for UUID-like representation"
+        end
       when Integer
         raise TypeError, "Integer must be between 0 and 2**64" if bytes < 0 or bytes > 2**64
         @bytes = [bytes >> 32, bytes % 2**32].pack("NN")
-      when NilClass
+      when NilClass, Time
         # Time.stamp is 52 bytes, so we have 12 bytes of entropy left over
-        int = (Time.stamp << 12) + rand(2**12)
+        int = ((bytes || Time).stamp << 12) + rand(2**12)
         @bytes = [int >> 32, int % 2**32].pack("NN")
       else
         raise TypeError, "Can't convert from #{bytes.class}"
@@ -23,11 +31,15 @@ class Cassandra
     def to_i
       @to_i ||= begin
         ints = @bytes.unpack("NN")
-        (ints[0] << 32) + 
+        (ints[0] << 32) +
         ints[1]
       end
-    end    
+    end
     
+    def to_guid
+      "%08x-%04x-%04x" % @bytes.unpack("Nnn")
+    end    
+
     def inspect
       "<Cassandra::Long##{object_id} time: #{
         Time.at((to_i >> 12) / 1_000_000).inspect
@@ -35,7 +47,9 @@ class Cassandra
         (to_i >> 12) % 1_000_000
       }, jitter: #{
         to_i % 2**12
+      }, guid: #{
+        to_guid
       }>"
-    end      
-  end  
+    end
+  end
 end

data/lib/cassandra/protocol.rb

@@ -4,20 +4,8 @@ class Cassandra
   module Protocol #:nodoc:
     private
 
-    def _insert(mutation, consistency)
-      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
-
-    def _remove(column_family, key, column, sub_column, consistency, timestamp)
-      column_path_or_parent = if is_super(column_family)
-        CassandraThrift::ColumnPath.new(:column_family => column_family, :super_column => column, :column => sub_column)
-      else
-        CassandraThrift::ColumnPath.new(:column_family => column_family, :column => column)
-      end
-      @client.remove(@keyspace, key, column_path_or_parent, timestamp, consistency)
+    def _mutate(mutation, consistency)
+      @client.batch_mutate(@keyspace, mutation, consistency)
     end
 
     def _count_columns(column_family, key, super_column, consistency)

data/lib/cassandra/uuid.rb

@@ -8,45 +8,45 @@ class Cassandra
     end
 
     GREGORIAN_EPOCH_OFFSET = 0x01B2_1DD2_1381_4000 # Oct 15, 1582
-    
+
     VARIANT = 0b1000_0000_0000_0000
 
     def initialize(bytes = nil)
       case bytes
       when String
         case bytes.size
-        when 16
-          @bytes = bytes          
-        when 36
+        when 16 # Raw byte array
+          @bytes = bytes
+        when 36 # Human-readable UUID representation; inverse of #to_guid
           elements = bytes.split("-")
           raise TypeError, "Malformed UUID representation" if elements.size != 5
-          @bytes = elements.join.to_a.pack('H32')          
+          @bytes = elements.join.to_a.pack('H32')
         else
           raise TypeError, "16 bytes required for byte array, or 36 characters required for UUID representation"
         end
-        
+
       when Integer
         raise TypeError, "Integer must be between 0 and 2**128" if bytes < 0 or bytes > 2**128
         @bytes = [
-          (bytes >> 96) & 0xFFFF_FFFF, 
-          (bytes >> 64) & 0xFFFF_FFFF, 
-          (bytes >> 32) & 0xFFFF_FFFF, 
+          (bytes >> 96) & 0xFFFF_FFFF,
+          (bytes >> 64) & 0xFFFF_FFFF,
+          (bytes >> 32) & 0xFFFF_FFFF,
           bytes & 0xFFFF_FFFF
         ].pack("NNNN")
-        
+
       when NilClass, Time
         time = (bytes || Time).stamp * 10 + GREGORIAN_EPOCH_OFFSET
         # See http://github.com/spectra/ruby-uuid/
         @bytes = [
-          time & 0xFFFF_FFFF, 
-          time >> 32, 
-          ((time >> 48) & 0x0FFF) | 0x1000, 
-          # Top 3 bytes reserved         
+          time & 0xFFFF_FFFF,
+          time >> 32,
+          ((time >> 48) & 0x0FFF) | 0x1000,
+          # Top 3 bytes reserved
           rand(2**13) | VARIANT,
           rand(2**16),
           rand(2**32)
         ].pack("NnnnnN")
-        
+
       else
         raise TypeError, "Can't convert from #{bytes.class}"
       end
@@ -54,9 +54,9 @@ class Cassandra
 
     def to_i
       ints = @bytes.unpack("NNNN")
-      (ints[0] << 96) + 
-      (ints[1] << 64) + 
-      (ints[2] << 32) + 
+      (ints[0] << 96) +
+      (ints[1] << 64) +
+      (ints[2] << 32) +
       ints[3]
     end
 
@@ -65,7 +65,7 @@ class Cassandra
       version = (time_high & 0xF000).to_s(16)[0].chr.to_i
       version > 0 and version < 6 ? version : -1
     end
-    
+
     def variant
       @bytes.unpack('QnnN')[1] >> 13
     end
@@ -76,19 +76,19 @@ class Cassandra
       elements[-1] = '%02x%02x%02x%02x%02x%02x' % node
       "%08x-%04x-%04x-%02x%02x-%s" % elements
     end
-    
+
     def seconds
       total_usecs / 1_000_000
     end
-    
+
     def usecs
-      total_usecs % 1_000_000    
+      total_usecs % 1_000_000
     end
-    
+
     def <=>(other)
       total_usecs <=> other.send(:total_usecs)
     end
-        
+
     def inspect(long = false)
       "<Cassandra::UUID##{object_id} time: #{
         Time.at(seconds).inspect
@@ -97,13 +97,13 @@ class Cassandra
       } jitter: #{
         @bytes.unpack('QQ')[1]
       }" + (long ? ", version: #{version}, variant: #{variant}, guid: #{to_guid}>" :  ">")
-    end    
-    
+    end
+
     private
-    
+
     def total_usecs
       elements = @bytes.unpack("NnnQ")
-      (elements[0] + (elements[1] << 32) + ((elements[2] & 0x0FFF) << 48) - GREGORIAN_EPOCH_OFFSET) / 10      
+      (elements[0] + (elements[1] << 32) + ((elements[2] & 0x0FFF) << 48) - GREGORIAN_EPOCH_OFFSET) / 10
     end
   end
 end

data/test/cassandra_test.rb

@@ -6,9 +6,15 @@ class CassandraTest < Test::Unit::TestCase
   def setup
     @twitter = Cassandra.new('Twitter', '127.0.0.1')
     @twitter.clear_keyspace!
+
     @blogs = Cassandra.new('Multiblog', '127.0.0.1')
     @blogs.clear_keyspace!
-    @uuids = (0..6).map {|i| UUID.new(Time.at(2**(24+i))) }    
+
+    @blogs_long = Cassandra.new('MultiblogLong', '127.0.0.1')
+    @blogs_long.clear_keyspace!
+
+    @uuids = (0..6).map {|i| UUID.new(Time.at(2**(24+i))) }
+    @longs = (0..6).map {|i| Long.new(Time.at(2**(24+i))) }
   end
 
   def test_inspect
@@ -19,21 +25,21 @@ class CassandraTest < Test::Unit::TestCase
   end
 
   def test_connection_reopens
-    assert_raises(NoMethodError) do
-      @twitter.insert(:Statuses, 1, {'body' => 'v'})
+    assert_raises(Thrift::ProtocolException) do
+      @twitter.send("_mutate", [], -5)
     end
     assert_nothing_raised do
       @twitter.insert(:Statuses, key, {'body' => 'v'})
     end
   end
 
-  def test_get_key_name_sorted
+  def test_get_key
     @twitter.insert(:Users, key, {'body' => 'v', 'user' => 'v'})
     assert_equal({'body' => 'v', 'user' => 'v'}, @twitter.get(:Users, key))
     assert_equal({}, @twitter.get(:Users, 'bogus'))
   end
 
-  def test_get_key_name_sorted_preserving_order
+  def test_get_key_preserving_order
     # In-order hash is preserved
     hash = OrderedHash['a', '', 'b', '', 'c', '', 'd', '',]
     @twitter.insert(:Users, key, hash)
@@ -48,17 +54,38 @@ class CassandraTest < Test::Unit::TestCase
     assert_not_equal(hash.keys, @twitter.get(:Users, key).keys)
   end
 
-  def test_get_key_time_sorted
-    @blogs.insert(:Blogs, key, {@uuids[0] => 'I like this cat'})     
-    assert_equal({@uuids[0] => 'I like this cat'}, @blogs.get(:Blogs, key))
+  def test_get_first_time_uuid_column
+    @blogs.insert(:Blogs, key, 
+      {@uuids[0] => 'I like this cat', @uuids[1] => 'Buttons is cuter', @uuids[2] => 'I disagree'})
+    
+    assert_equal({@uuids[0] => 'I like this cat'}, @blogs.get(:Blogs, key, :count => 1))
+    assert_equal({@uuids[2] => 'I disagree'}, @blogs.get(:Blogs, key, :count => 1, :reversed => true))
     assert_equal({}, @blogs.get(:Blogs, 'bogus'))
   end
 
+  def test_get_first_long_column
+    @blogs_long.insert(:Blogs, key, 
+      {@longs[0] => 'I like this cat', @longs[1] => 'Buttons is cuter', @longs[2] => 'I disagree'})
+    
+    assert_equal({@longs[0] => 'I like this cat'}, @blogs_long.get(:Blogs, key, :count => 1))
+    assert_equal({@longs[2] => 'I disagree'}, @blogs_long.get(:Blogs, key, :count => 1, :reversed => true))
+    assert_equal({}, @blogs_long.get(:Blogs, 'bogus'))
+  end
+  
+  def test_long_remove_bug
+    @blogs_long.insert(:Blogs, key, {@longs[0] => 'I like this cat'})
+    @blogs_long.remove(:Blogs, key)
+    assert_equal({}, @blogs_long.get(:Blogs, key, :count => 1))
+
+    @blogs_long.insert(:Blogs, key, {@longs[0] => 'I like this cat'})
+    assert_equal({@longs[0] => 'I like this cat'}, @blogs_long.get(:Blogs, key, :count => 1))
+  end
+
   def test_get_with_count
     @twitter.insert(:Statuses, key, {'1' => 'v', '2' => 'v', '3' => 'v'})
     assert_equal 1, @twitter.get(:Statuses, key, :count => 1).size
     assert_equal 2, @twitter.get(:Statuses, key, :count => 2).size
-  end  
+  end
 
   def test_get_value
     @twitter.insert(:Statuses, key, {'body' => 'v'})
@@ -68,7 +95,7 @@ class CassandraTest < Test::Unit::TestCase
     assert @twitter.exists?(:Statuses, key, 'body')
     assert_nil @twitter.exists?(:Statuses, 'bogus', 'body')
   end
-  
+
   def test_get_super_key
     columns = {'user_timelines' => {@uuids[4] => '4', @uuids[5] => '5'}}
     @twitter.insert(:StatusRelationships, key, columns)
@@ -87,25 +114,25 @@ class CassandraTest < Test::Unit::TestCase
   end
 
   def test_get_super_sub_keys_with_count
-    @twitter.insert(:StatusRelationships, key, 
+    @twitter.insert(:StatusRelationships, key,
       {'user_timelines' => {@uuids[1]  => 'v1', @uuids[2]  => 'v2', @uuids[3]  => 'v3'}})
-    assert_equal({@uuids[1]  => 'v1'}, 
+    assert_equal({@uuids[1]  => 'v1'},
       @twitter.get(:StatusRelationships, key, "user_timelines", :count => 1))
-    assert_equal({@uuids[3]  => 'v3'}, 
+    assert_equal({@uuids[3]  => 'v3'},
       @twitter.get(:StatusRelationships, key, "user_timelines", :count => 1, :reversed => true))
   end
 
-  def test_get_super_sub_keys_with_ranges              
-    @twitter.insert(:StatusRelationships, key, 
+  def test_get_super_sub_keys_with_ranges
+    @twitter.insert(:StatusRelationships, key,
       {'user_timelines' => {
-        @uuids[1] => 'v1', 
-        @uuids[2] => 'v2', 
+        @uuids[1] => 'v1',
+        @uuids[2] => 'v2',
         @uuids[3] => 'v3',
-        @uuids[4] => 'v4', 
+        @uuids[4] => 'v4',
         @uuids[5] => 'v5'}})
 
     keys = @twitter.get(:StatusRelationships, key, "user_timelines").keys
-    assert_equal keys.sort, keys    
+    assert_equal keys.sort, keys
     assert_equal({@uuids[1] => 'v1'}, @twitter.get(:StatusRelationships, key, "user_timelines", :finish => @uuids[2], :count => 1))
     assert_equal({@uuids[2] => 'v2'}, @twitter.get(:StatusRelationships, key, "user_timelines", :start => @uuids[2], :count => 1))
     assert_equal 4, @twitter.get(:StatusRelationships, key, "user_timelines", :start => @uuids[2], :finish => @uuids[5]).size
@@ -222,15 +249,6 @@ class CassandraTest < Test::Unit::TestCase
       @twitter.multi_get_columns(:Users, [key + '2', 'bogus', key + '1'], ['body', 'user']))
   end
 
-  # Not supported
-  #  def test_get_columns_super_sub
-  #    @twitter.insert(:StatusRelationships, key, {
-  #      'user_timelines' => {@uuids[1] => 'v1'},
-  #      'mentions_timelines' => {@uuids[2] => 'v2'}})
-  #    assert_equal ['v1', 'v2'],
-  #      @twitter.get_columns(:StatusRelationships, key, 'user_timelines', ['1', key])
-  #  end
-
   def test_count_keys
     @twitter.insert(:Statuses, key + "1", {'body' => '1'})
     @twitter.insert(:Statuses, key + "2", {'body' => '2'})
@@ -266,7 +284,7 @@ class CassandraTest < Test::Unit::TestCase
       @twitter.multi_count_columns(:Users, [key + '2', 'bogus', key + '1']))
   end
 
-  def test_batch_insert
+  def test_batch_mutate
     @twitter.insert(:Users, key + '1', {'body' => 'v1', 'user' => 'v1'})
 
     @twitter.batch do

data/test/comparable_types_test.rb

@@ -13,6 +13,7 @@ class ComparableTypesTest < Test::Unit::TestCase
     long = Long.new
     assert_equal long, Long.new(long.to_s)  
     assert_equal long, Long.new(long.to_i)  
+    assert_equal long, Long.new(long.to_guid)  
   end
   
   def test_long_error

data/vendor/gen-rb/cassandra.rb

@@ -78,17 +78,17 @@ require 'cassandra_types'
             return
           end
 
-          def batch_insert(keyspace, batch_mutation, consistency_level)
-            send_batch_insert(keyspace, batch_mutation, consistency_level)
-            recv_batch_insert()
+          def batch_mutate(keyspace, batch_mutations, consistency_level)
+            send_batch_mutate(keyspace, batch_mutations, consistency_level)
+            recv_batch_mutate()
           end
 
-          def send_batch_insert(keyspace, batch_mutation, consistency_level)
-            send_message('batch_insert', Batch_insert_args, :keyspace => keyspace, :batch_mutation => batch_mutation, :consistency_level => consistency_level)
+          def send_batch_mutate(keyspace, batch_mutations, consistency_level)
+            send_message('batch_mutate', Batch_mutate_args, :keyspace => keyspace, :batch_mutations => batch_mutations, :consistency_level => consistency_level)
           end
 
-          def recv_batch_insert()
-            result = receive_message(Batch_insert_result)
+          def recv_batch_mutate()
+            result = receive_message(Batch_mutate_result)
             raise result.ire unless result.ire.nil?
             raise result.ue unless result.ue.nil?
             return
@@ -110,22 +110,6 @@ require 'cassandra_types'
             return
           end
 
-          def batch_insert_super_column(keyspace, batch_mutation_super, consistency_level)
-            send_batch_insert_super_column(keyspace, batch_mutation_super, consistency_level)
-            recv_batch_insert_super_column()
-          end
-
-          def send_batch_insert_super_column(keyspace, batch_mutation_super, consistency_level)
-            send_message('batch_insert_super_column', Batch_insert_super_column_args, :keyspace => keyspace, :batch_mutation_super => batch_mutation_super, :consistency_level => consistency_level)
-          end
-
-          def recv_batch_insert_super_column()
-            result = receive_message(Batch_insert_super_column_result)
-            raise result.ire unless result.ire.nil?
-            raise result.ue unless result.ue.nil?
-            return
-          end
-
           def get_key_range(keyspace, column_family, start, finish, count)
             send_get_key_range(keyspace, column_family, start, finish, count)
             return recv_get_key_range()
@@ -243,17 +227,17 @@ require 'cassandra_types'
             write_result(result, oprot, 'insert', seqid)
           end
 
-          def process_batch_insert(seqid, iprot, oprot)
-            args = read_args(iprot, Batch_insert_args)
-            result = Batch_insert_result.new()
+          def process_batch_mutate(seqid, iprot, oprot)
+            args = read_args(iprot, Batch_mutate_args)
+            result = Batch_mutate_result.new()
             begin
-              @handler.batch_insert(args.keyspace, args.batch_mutation, args.consistency_level)
+              @handler.batch_mutate(args.keyspace, args.batch_mutations, args.consistency_level)
             rescue CassandraThrift::InvalidRequestException => ire
               result.ire = ire
             rescue CassandraThrift::UnavailableException => ue
               result.ue = ue
             end
-            write_result(result, oprot, 'batch_insert', seqid)
+            write_result(result, oprot, 'batch_mutate', seqid)
           end
 
           def process_remove(seqid, iprot, oprot)
@@ -269,19 +253,6 @@ require 'cassandra_types'
             write_result(result, oprot, 'remove', seqid)
           end
 
-          def process_batch_insert_super_column(seqid, iprot, oprot)
-            args = read_args(iprot, Batch_insert_super_column_args)
-            result = Batch_insert_super_column_result.new()
-            begin
-              @handler.batch_insert_super_column(args.keyspace, args.batch_mutation_super, args.consistency_level)
-            rescue CassandraThrift::InvalidRequestException => ire
-              result.ire = ire
-            rescue CassandraThrift::UnavailableException => ue
-              result.ue = ue
-            end
-            write_result(result, oprot, 'batch_insert_super_column', seqid)
-          end
-
           def process_get_key_range(seqid, iprot, oprot)
             args = read_args(iprot, Get_key_range_args)
             result = Get_key_range_result.new()
@@ -504,16 +475,16 @@ require 'cassandra_types'
 
         end
 
-        class Batch_insert_args
+        class Batch_mutate_args
           include ::Thrift::Struct
           KEYSPACE = 1
-          BATCH_MUTATION = 2
+          BATCH_MUTATIONS = 2
           CONSISTENCY_LEVEL = 3
 
-          ::Thrift::Struct.field_accessor self, :keyspace, :batch_mutation, :consistency_level
+          ::Thrift::Struct.field_accessor self, :keyspace, :batch_mutations, :consistency_level
           FIELDS = {
             KEYSPACE => {:type => ::Thrift::Types::STRING, :name => 'keyspace'},
-            BATCH_MUTATION => {:type => ::Thrift::Types::STRUCT, :name => 'batch_mutation', :class => CassandraThrift::BatchMutation},
+            BATCH_MUTATIONS => {:type => ::Thrift::Types::LIST, :name => 'batch_mutations', :element => {:type => ::Thrift::Types::STRUCT, :class => CassandraThrift::BatchMutation}},
             CONSISTENCY_LEVEL => {:type => ::Thrift::Types::I32, :name => 'consistency_level', :default =>             0, :enum_class => CassandraThrift::ConsistencyLevel}
           }
 
@@ -527,7 +498,7 @@ require 'cassandra_types'
 
         end
 
-        class Batch_insert_result
+        class Batch_mutate_result
           include ::Thrift::Struct
           IRE = 1
           UE = 2
@@ -590,47 +561,6 @@ require 'cassandra_types'
 
         end
 
-        class Batch_insert_super_column_args
-          include ::Thrift::Struct
-          KEYSPACE = 1
-          BATCH_MUTATION_SUPER = 2
-          CONSISTENCY_LEVEL = 3
-
-          ::Thrift::Struct.field_accessor self, :keyspace, :batch_mutation_super, :consistency_level
-          FIELDS = {
-            KEYSPACE => {:type => ::Thrift::Types::STRING, :name => 'keyspace'},
-            BATCH_MUTATION_SUPER => {:type => ::Thrift::Types::STRUCT, :name => 'batch_mutation_super', :class => CassandraThrift::BatchMutationSuper},
-            CONSISTENCY_LEVEL => {:type => ::Thrift::Types::I32, :name => 'consistency_level', :default =>             0, :enum_class => CassandraThrift::ConsistencyLevel}
-          }
-
-          def struct_fields; FIELDS; end
-
-          def validate
-            unless @consistency_level.nil? || CassandraThrift::ConsistencyLevel::VALID_VALUES.include?(@consistency_level)
-              raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field consistency_level!')
-            end
-          end
-
-        end
-
-        class Batch_insert_super_column_result
-          include ::Thrift::Struct
-          IRE = 1
-          UE = 2
-
-          ::Thrift::Struct.field_accessor self, :ire, :ue
-          FIELDS = {
-            IRE => {:type => ::Thrift::Types::STRUCT, :name => 'ire', :class => CassandraThrift::InvalidRequestException},
-            UE => {:type => ::Thrift::Types::STRUCT, :name => 'ue', :class => CassandraThrift::UnavailableException}
-          }
-
-          def struct_fields; FIELDS; end
-
-          def validate
-          end
-
-        end
-
         class Get_key_range_args
           include ::Thrift::Struct
           KEYSPACE = 1

data/vendor/gen-rb/cassandra_types.rb

@@ -35,24 +35,6 @@ module CassandraThrift
 
     end
 
-    class BatchMutation
-      include ::Thrift::Struct
-      KEY = 1
-      CFMAP = 2
-
-      ::Thrift::Struct.field_accessor self, :key, :cfmap
-      FIELDS = {
-        KEY => {:type => ::Thrift::Types::STRING, :name => 'key'},
-        CFMAP => {:type => ::Thrift::Types::MAP, :name => 'cfmap', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::LIST, :element => {:type => ::Thrift::Types::STRUCT, :class => CassandraThrift::Column}}}
-      }
-
-      def struct_fields; FIELDS; end
-
-      def validate
-      end
-
-    end
-
     class SuperColumn
       include ::Thrift::Struct
       NAME = 1
@@ -71,15 +53,15 @@ module CassandraThrift
 
     end
 
-    class BatchMutationSuper
+    class ColumnOrSuperColumn
       include ::Thrift::Struct
-      KEY = 1
-      CFMAP = 2
+      COLUMN = 1
+      SUPER_COLUMN = 2
 
-      ::Thrift::Struct.field_accessor self, :key, :cfmap
+      ::Thrift::Struct.field_accessor self, :column, :super_column
       FIELDS = {
-        KEY => {:type => ::Thrift::Types::STRING, :name => 'key'},
-        CFMAP => {:type => ::Thrift::Types::MAP, :name => 'cfmap', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::LIST, :element => {:type => ::Thrift::Types::STRUCT, :class => CassandraThrift::SuperColumn}}}
+        COLUMN => {:type => ::Thrift::Types::STRUCT, :name => 'column', :class => CassandraThrift::Column, :optional => true},
+        SUPER_COLUMN => {:type => ::Thrift::Types::STRUCT, :name => 'super_column', :class => CassandraThrift::SuperColumn, :optional => true}
       }
 
       def struct_fields; FIELDS; end
@@ -163,12 +145,14 @@ module CassandraThrift
       COLUMN_FAMILY = 3
       SUPER_COLUMN = 4
       COLUMN = 5
+      TIMESTAMP = 6
 
-      ::Thrift::Struct.field_accessor self, :column_family, :super_column, :column
+      ::Thrift::Struct.field_accessor self, :column_family, :super_column, :column, :timestamp
       FIELDS = {
         COLUMN_FAMILY => {:type => ::Thrift::Types::STRING, :name => 'column_family'},
         SUPER_COLUMN => {:type => ::Thrift::Types::STRING, :name => 'super_column', :optional => true},
-        COLUMN => {:type => ::Thrift::Types::STRING, :name => 'column', :optional => true}
+        COLUMN => {:type => ::Thrift::Types::STRING, :name => 'column', :optional => true},
+        TIMESTAMP => {:type => ::Thrift::Types::I64, :name => 'timestamp', :optional => true}
       }
 
       def struct_fields; FIELDS; end
@@ -218,15 +202,17 @@ module CassandraThrift
 
     end
 
-    class ColumnOrSuperColumn
+    class BatchMutation
       include ::Thrift::Struct
-      COLUMN = 1
-      SUPER_COLUMN = 2
+      KEY = 1
+      CFMAP = 2
+      COLUMN_PATHS = 3
 
-      ::Thrift::Struct.field_accessor self, :column, :super_column
+      ::Thrift::Struct.field_accessor self, :key, :cfmap, :column_paths
       FIELDS = {
-        COLUMN => {:type => ::Thrift::Types::STRUCT, :name => 'column', :class => CassandraThrift::Column, :optional => true},
-        SUPER_COLUMN => {:type => ::Thrift::Types::STRUCT, :name => 'super_column', :class => CassandraThrift::SuperColumn, :optional => true}
+        KEY => {:type => ::Thrift::Types::STRING, :name => 'key'},
+        CFMAP => {:type => ::Thrift::Types::MAP, :name => 'cfmap', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::LIST, :element => {:type => ::Thrift::Types::STRUCT, :class => CassandraThrift::ColumnOrSuperColumn}}},
+        COLUMN_PATHS => {:type => ::Thrift::Types::LIST, :name => 'column_paths', :element => {:type => ::Thrift::Types::STRUCT, :class => CassandraThrift::ColumnPath}}
       }
 
       def struct_fields; FIELDS; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cassandra
 version: !ruby/object:Gem::Version 
-  version: 0.5.4
+  version: 0.5.5
 platform: ruby
 authors: 
 - Evan Weaver
@@ -30,7 +30,7 @@ cert_chain:
   yZ0=
   -----END CERTIFICATE-----
 
-date: 2009-08-19 00:00:00 -04:00
+date: 2009-08-27 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -67,6 +67,7 @@ extra_rdoc_files:
 - lib/cassandra/columns.rb
 - lib/cassandra/comparable.rb
 - lib/cassandra/constants.rb
+- lib/cassandra/debug.rb
 - lib/cassandra/long.rb
 - lib/cassandra/ordered_hash.rb
 - lib/cassandra/protocol.rb
@@ -87,6 +88,7 @@ files:
 - lib/cassandra/columns.rb
 - lib/cassandra/comparable.rb
 - lib/cassandra/constants.rb
+- lib/cassandra/debug.rb
 - lib/cassandra/long.rb
 - lib/cassandra/ordered_hash.rb
 - lib/cassandra/protocol.rb