cassandra 0.10.0 → 0.11.0

data/CHANGELOG

@@ -1,3 +1,11 @@
+v0.11.0
+- Remove direct thrift dependency. Allow thrift_client to require it.
+- Add functions for each and each_key to iterate through key ranges.
+- Add function for get_range_keys which returns an array of keys in a given range.
+- Changed the return value of get_range to an OrderedHash.
+- Change get_range to accept both a range of keys and a range of columns.
+- Add batched range support to get_range and add get_range_batch.
+
 v0.10.0 Major Update (rjackson)
 - Update Rakefile to install 0.6.13, 0.7.4, 0.8.0-beta1 to ~/cassandra/cassandra-VERSION
 - Add data:load task to Rakefile for creating the schema required for the tests

data/Rakefile

@@ -42,10 +42,7 @@ def setup_cassandra_version(version = CASSANDRA_VERSION)
   end
 end
 
-desc "Start Cassandra"
-task :cassandra => :java do
-  setup_cassandra_version
-
+def setup_environment
   env = ""
   if !ENV["CASSANDRA_INCLUDE"]
     env << "CASSANDRA_INCLUDE=#{File.expand_path(Dir.pwd)}/conf/#{CASSANDRA_VERSION}/cassandra.in.sh "
@@ -57,13 +54,26 @@ task :cassandra => :java do
     env << "CASSANDRA_CONF=#{ENV['CASSANDRA_CONF']}"
   end
 
-  puts env
+  env
+end
+
+desc "Start Cassandra"
+task :cassandra => :java do
+  setup_cassandra_version
+
+  env = setup_environment
 
   Dir.chdir(File.join(CASSANDRA_HOME, "cassandra-#{CASSANDRA_VERSION}")) do
     sh("env #{env} bin/cassandra -f")
   end
 end
 
+desc "Run the Cassandra CLI"
+task :cli do
+  Dir.chdir(File.join(CASSANDRA_HOME, "cassandra-#{CASSANDRA_VERSION}")) do
+    sh("bin/cassandra-cli -host localhost -port 9160")
+  end
+end
 
 desc "Check Java version"
 task :java do
@@ -85,15 +95,16 @@ namespace :data do
 
   desc "Load test data structures."
   task :load do
-    return true if CASSANDRA_VERSION == '0.6'
-
-    schema_path = "#{File.expand_path(Dir.pwd)}/conf/#{CASSANDRA_VERSION}/schema.txt"
-    puts "Loading test data structures."
-    Dir.chdir(File.join(CASSANDRA_HOME, "cassandra-#{CASSANDRA_VERSION}")) do
-      begin
-        sh("bin/cassandra-cli --host localhost --batch < #{schema_path}")
-      rescue
-        puts "Schema already loaded."
+    unless CASSANDRA_VERSION == '0.6'
+
+      schema_path = "#{File.expand_path(Dir.pwd)}/conf/#{CASSANDRA_VERSION}/schema.txt"
+      puts "Loading test data structures."
+      Dir.chdir(File.join(CASSANDRA_HOME, "cassandra-#{CASSANDRA_VERSION}")) do
+        begin
+          sh("bin/cassandra-cli --host localhost --batch < #{schema_path}")
+        rescue
+          puts "Schema already loaded."
+        end
       end
     end
   end

data/cassandra.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cassandra}
-  s.version = "0.10.0"
+  s.version = "0.11.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0.8") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan Weaver, Ryan King"]
-  s.date = %q{2011-04-28}
+  s.date = %q{2011-05-18}
   s.description = %q{A Ruby client for the Cassandra distributed database.}
   s.email = %q{}
   s.executables = ["cassandra_helper"]

data/lib/cassandra.rb

@@ -1,6 +1,4 @@
 require 'rubygems'
-gem 'thrift', '~> 0.5.0'
-require 'thrift'
 gem 'thrift_client', '~> 0.6.0'
 require 'thrift_client'
 gem 'simple_uuid' , '~> 0.1.0'

data/lib/cassandra/0.6/protocol.rb

@@ -71,22 +71,19 @@ class Cassandra
       end
     end
 
-    def _get_range(column_family, start, finish, count, consistency)
+    def _get_range(column_family, start_key, finish_key, key_count, columns, start, finish, count, consistency)
       column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
-      predicate = CassandraThrift::SlicePredicate.new(:slice_range => CassandraThrift::SliceRange.new(:start => '', :finish => ''))
-      range = CassandraThrift::KeyRange.new(:start_key => start, :end_key => finish, :count => count)
-      client.get_range_slices(@keyspace, column_parent, predicate, range, 1)
-    end
-    
-    def _get_range_keys(column_family, start, finish, count, consistency)
-      _get_range(column_family, start, finish, count, consistency).collect{|i| i.key }
-    end
-
-    def each_key(column_family)
-      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family.to_s)
-      predicate = CassandraThrift::SlicePredicate.new(:column_names => [])
-      range = CassandraThrift::KeyRange.new(:start_key => '', :end_key => '')
-      client.get_range_slices(@keyspace, column_parent, predicate, range, 1).each{|i| yield i.key }
+      predicate = if columns
+                    CassandraThrift::SlicePredicate.new(:column_names => columns)
+                  else
+                    CassandraThrift::SlicePredicate.new(:slice_range => 
+                      CassandraThrift::SliceRange.new(
+                        :start  => start, 
+                        :finish => finish,
+                        :count  => count))
+                  end
+      range = CassandraThrift::KeyRange.new(:start_key => start_key, :end_key => finish_key, :count => key_count)
+      client.get_range_slices(@keyspace, column_parent, predicate, range, consistency)
     end
   end
 end

data/lib/cassandra/0.7/protocol.rb

@@ -83,15 +83,19 @@ class Cassandra
       end
     end
 
-    def _get_range(column_family, start, finish, count, consistency)
+    def _get_range(column_family, start_key, finish_key, key_count, columns, start, finish, count, consistency)
       column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
-      predicate = CassandraThrift::SlicePredicate.new(:slice_range => CassandraThrift::SliceRange.new(:start => '', :finish => ''))
-      range = CassandraThrift::KeyRange.new(:start_key => start, :end_key => finish, :count => count)
-      client.get_range_slices(column_parent, predicate, range, 1)
-    end
-
-    def _get_range_keys(column_family, start, finish, count, consistency)
-      _get_range(column_family, start, finish, count, consistency).collect{|i| i.key }
+      predicate = if columns
+                    CassandraThrift::SlicePredicate.new(:column_names => columns)
+                  else
+                    CassandraThrift::SlicePredicate.new(:slice_range => 
+                      CassandraThrift::SliceRange.new(
+                        :start  => start, 
+                        :finish => finish,
+                        :count  => count))
+                  end
+      range = CassandraThrift::KeyRange.new(:start_key => start_key, :end_key => finish_key, :count => key_count)
+      client.get_range_slices(column_parent, predicate, range, consistency)
     end
 
     # TODO: Supercolumn support
@@ -109,12 +113,5 @@ class Cassandra
       end
       client.get_indexed_slices(column_parent, idx_clause, predicate, consistency)
     end
-
-    def each_key(column_family)
-      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family.to_s)
-      predicate = CassandraThrift::SlicePredicate.new(:column_names => [])
-      range = CassandraThrift::KeyRange.new(:start_key => '', :end_key => '')
-      client.get_range_slices(column_parent, predicate, range, 1).each{|i| yield i.key }
-    end
   end
 end

data/lib/cassandra/0.8/protocol.rb

@@ -83,15 +83,19 @@ class Cassandra
       end
     end
 
-    def _get_range(column_family, start, finish, count, consistency)
+    def _get_range(column_family, start_key, finish_key, key_count, columns, start, finish, count, consistency)
       column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
-      predicate = CassandraThrift::SlicePredicate.new(:slice_range => CassandraThrift::SliceRange.new(:start => '', :finish => ''))
-      range = CassandraThrift::KeyRange.new(:start_key => start, :end_key => finish, :count => count)
-      client.get_range_slices(column_parent, predicate, range, 1)
-    end
-
-    def _get_range_keys(column_family, start, finish, count, consistency)
-      _get_range(column_family, start, finish, count, consistency).collect{|i| i.key }
+      predicate = if columns
+                    CassandraThrift::SlicePredicate.new(:column_names => columns)
+                  else
+                    CassandraThrift::SlicePredicate.new(:slice_range => 
+                      CassandraThrift::SliceRange.new(
+                        :start => start, 
+                        :finish => finish,
+                        :count  => count))
+                  end
+      range = CassandraThrift::KeyRange.new(:start_key => start_key, :end_key => finish_key, :count => key_count)
+      client.get_range_slices(column_parent, predicate, range, consistency)
     end
 
     # TODO: Supercolumn support
@@ -109,12 +113,5 @@ class Cassandra
       end
       client.get_indexed_slices(column_parent, idx_clause, predicate, consistency)
     end
-
-    def each_key(column_family)
-      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family.to_s)
-      predicate = CassandraThrift::SlicePredicate.new(:column_names => [])
-      range = CassandraThrift::KeyRange.new(:start_key => '', :end_key => '')
-      client.get_range_slices(column_parent, predicate, range, 1).each{|i| yield i.key }
-    end
   end
 end

data/lib/cassandra/cassandra.rb

@@ -30,7 +30,7 @@ For write methods, valid option parameters are:
 
 For the initial client instantiation, you may also pass in <tt>:thrift_client<tt> with a ThriftClient subclass attached. On connection, that class will be used instead of the default ThriftClient class, allowing you to add additional behavior to the connection (e.g. query logging).
 
-=end rdoc
+=end
 
 class Cassandra
   include Columns
@@ -226,21 +226,120 @@ class Cassandra
     end
   end
 
-  # Return a list of keys in the column_family you request. Only works well if
+  # Return an OrderedHash containing the columns specified for the given
+  # range of keys in the column_family you request. Only works well if
   # the table is partitioned with OrderPreservingPartitioner. Supports the
-  # <tt>:count</tt>, <tt>:start</tt>, <tt>:finish</tt>, and <tt>:consistency</tt>
-  # options.
+  # <tt>:key_count</tt>, <tt>:start_key</tt>, <tt>:finish_key</tt>,
+  # <tt>:columns</tt>, <tt>:start</tt>, <tt>:finish</tt>, <tt>:count</tt>,
+  # and <tt>:consistency</tt> options. Please note that Cassandra returns
+  # a row for each row that has existed in the system since gc_grace_seconds.
+  # This is because deleted row keys are marked as deleted, but left in the
+  # system until the cluster has had resonable time to replicate the deletion.
+  # This function attempts to suppress deleted rows (actually any row returned without
+  # columns is suppressed).
   def get_range(column_family, options = {})
+    if block_given? || options[:key_count] || options[:batch_size]
+      get_range_batch(column_family, options)
+    else
+      get_range_single(column_family, options)
+    end
+  end
+
+  def get_range_single(column_family, options = {})
+    return_empty_rows = options.delete(:return_empty_rows) || false
+
     column_family, _, _, options = 
-      extract_and_validate_params(column_family, "", [options], READ_DEFAULTS)
-    _get_range(column_family, options[:start].to_s, options[:finish].to_s, options[:count], options[:consistency])
+      extract_and_validate_params(column_family, "", [options], 
+                                  READ_DEFAULTS.merge(:start_key  => '',
+                                                      :end_key    => '',
+                                                      :key_count  => 100,
+                                                      :columns    => nil
+                                                     )
+                                 )
+
+    results = _get_range( column_family,
+                          options[:start_key].to_s,
+                          options[:finish_key].to_s,
+                          options[:key_count],
+                          options[:columns],
+                          options[:start].to_s,
+                          options[:finish].to_s,
+                          options[:count],
+                          options[:consistency] )
+
+    multi_key_slices_to_hash(column_family, results, return_empty_rows)
+  end
+
+  def get_range_batch(column_family, options = {})
+    batch_size    = options.delete(:batch_size) || 100
+    count         = options.delete(:key_count)
+    result        = {}
+
+    options[:start_key] ||= ''
+    last_key  = nil
+
+    while options[:start_key] != last_key && (count.nil? || count > result.length)
+      options[:start_key] = last_key
+      res = get_range_single(column_family, options.merge!(:start_key => last_key,
+                                                           :key_count => batch_size,
+                                                           :return_empty_rows => true
+                                                          ))
+      res.each do |key, columns|
+        next if options[:start_key] == key
+        next if result.length == count
+
+        unless columns == {}
+          yield key, columns if block_given?
+          result[key] = columns
+        end
+        last_key = key
+      end
+    end
+
+    result
   end
 
-  # 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.
+  # Count all rows in the column_family you request. Supports the <tt>:start_key</tt>,
+  # <tt>:finish_key</tt>, and <tt>:consistency</tt> options.  Please note that 
+  # <tt>:start_key</tt> and <tt>:finish_key</tt> only work properly when
+  # OrderPreservingPartitioner.
   def count_range(column_family, options = {})
-    get_range(column_family, options).select{|r| r.columns.length > 0}.compact.length
+    get_range_keys(column_family, options).length
+  end
+
+  # Return an Array containing all of the keys within a given range. (Only works
+  # properly if the Cassandra cluster is using the OrderPreservingPartitioner.)
+  # Supports <tt>:start_key</tt>, <tt>:finish_key</tt>, <tt>:count</tt>, and
+  # <tt>:consistency</tt> options.
+  def get_range_keys(column_family, options = {})
+    get_range(column_family,options.merge!(:count => 1)).keys
+  end
+
+  # Iterate through each key within the given parameters. This function can be
+  # used to iterate over each key in the given column family. However, if you
+  # only want to walk through a range of keys you need to have your cluster
+  # setup with OrderPreservingPartitioner. Please note that this function walks
+  # the list of keys in batches using the passed in <tt>:count</tt> option.
+  # Supports <tt>:start_key</tt>, <tt>:finish_key</tt>, <tt>:count</tt>, and
+  # <tt>:consistency</tt> options.
+  def each_key(column_family, options = {})
+    get_range_batch(column_family, options) do |key, columns|
+      yield key
+    end
+  end
+
+  # Iterate through each row and yields each key and value within the given parameters.
+  # This function can be used to iterate over each key in the given column family.
+  # However, if you only want to walk through a range of keys you need to have your
+  # cluster setup with OrderPreservingPartitioner. Please note that this function walks
+  # the list of keys in batches using the passed in <tt>:count</tt> option.
+  # Supports the <tt>:key_count</tt>, <tt>:start_key</tt>, <tt>:finish_key</tt>,
+  # <tt>:columns</tt>, <tt>:start</tt>, <tt>:finish</tt>, <tt>:count</tt>,
+  # and <tt>:consistency</tt> options.
+  def each(column_family, options = {})
+    get_range_batch(column_family, options) do |key, columns|
+      yield key, columns
+    end
   end
 
   # Open a batch operation and yield self. Inserts and deletes will be queued

data/lib/cassandra/columns.rb

@@ -34,6 +34,15 @@ class Cassandra
       schema[column_family][key]
     end
 
+    def multi_key_slices_to_hash(column_family, array, return_empty_rows = false)
+      ret = {}
+      array.each do |value|
+        next if return_empty_rows == false && value.columns.length == 0
+        ret[value.key] = columns_to_hash(column_family, value.columns)
+      end
+      ret
+    end
+
     def multi_column_to_hash!(hash)
       hash.each do |key, column_or_supercolumn|
         hash[key] = (column_or_supercolumn.column.value if column_or_supercolumn.column)

data/lib/cassandra/mock.rb

@@ -181,19 +181,57 @@ class Cassandra
     end
 
     def get_range(column_family, options = {})
-      column_family, _, _, options = extract_and_validate_params_for_real(column_family, "", [options], READ_DEFAULTS)
-      _get_range(column_family, options[:start], options[:finish], options[:count]).keys
+      column_family, _, _, options = extract_and_validate_params_for_real(column_family, "", [options], 
+                                                                          READ_DEFAULTS.merge(:start_key  => '',
+                                                                                              :end_key    => '',
+                                                                                              :key_count  => 100,
+                                                                                              :columns    => nil
+                                                                                             )
+                                                                         )
+      _get_range(column_family,
+                 options[:start_key],
+                 options[:finish_key],
+                 options[:key_count],
+                 options[:columns],
+                 options[:start],
+                 options[:finish],
+                 options[:count],
+                 options[:consistency])
+    end
+
+    def get_range_keys(column_family, options = {})
+      get_range(column_family,options.merge!(:columns => [])).keys
+    end
+
+    def count_range(column_family, options = {})
+      get_range(column_family, options).select{|k,v| v.length > 0}.keys.compact.length
+    end
+
+    def each_key(column_family, options = {})
+      each(column_family, options.merge!(:columns => [])) do |key, value|
+        yield key
+      end
     end
 
-    def count_range(column_family, options={})
-      count = 0
-      l = []
-      start_key = ''
-      while (l = get_range(column_family, options.merge(:count => 1000, :start => start_key))).size > 0
-        count += l.size
-        start_key = l.last.succ
+    def each(column_family, options = {})
+      batch_size    = options.delete(:batch_size) || 100
+      count         = options.delete(:key_count)
+      yielded_count = 0
+
+      options[:start_key] ||= ''
+      last_key  = nil
+
+      while options[:start_key] != last_key && (count.nil? || count > yielded_count)
+        options[:start_key] = last_key
+        res = get_range(column_family, options.merge!(:start_key => last_key, :key_count => batch_size))
+        res.each do |key, columns|
+          next if options[:start_key] == key
+          next if yielded_count == count
+          yield key, columns
+          yielded_count += 1
+          last_key = key
+        end
       end
-      count
     end
 
     def create_index(ks_name, cf_name, c_name, v_class)
@@ -264,14 +302,18 @@ class Cassandra
       @schema
     end
 
-    def _get_range(column_family, start, finish, count)
+    def _get_range(column_family, start_key, finish_key, key_count, columns, start, finish, count, consistency)
       ret = OrderedHash.new
       start  = to_compare_with_type(start,  column_family)
       finish = to_compare_with_type(finish, column_family)
       cf(column_family).keys.sort.each do |key|
-        break if ret.keys.size >= count
-        if (start.nil? || key >= start) && (finish.nil? || key <= finish)
-          ret[key] = cf(column_family)[key]
+        break if ret.keys.size >= key_count
+        if (start_key.nil? || key >= start_key) && (finish_key.nil? || key <= finish_key)
+          if columns
+            ret[key] = columns.inject(OrderedHash.new){|hash, column_name| hash[column_name] = cf(column_family)[key][column_name]; hash;}
+          else
+            ret[key] = apply_range(cf(column_family)[key], column_family, start, finish, !is_super(column_family))
+          end
         end
       end
       ret

data/test/cassandra_mock_test.rb

@@ -38,7 +38,7 @@ class CassandraMockTest < CassandraTest
   def test_sorting_row_keys
     @twitter.insert(:Statuses, 'b', {:text => 'foo'})
     @twitter.insert(:Statuses, 'a', {:text => 'foo'})
-    assert_equal ['a'], @twitter.get_range(:Statuses, :count => 1)
+    assert_equal ['a'], @twitter.get_range(:Statuses, :key_count => 1).keys
   end
 
   def test_inserting_array_for_indices

data/test/cassandra_test.rb

@@ -43,7 +43,7 @@ class CassandraTest < Test::Unit::TestCase
     hash = OrderedHash['b', '', 'c', '', 'd', '', 'a', '']
     @twitter.insert(:Users, key, hash)
     assert_equal(hash.keys.sort, @twitter.get(:Users, key).keys)
-    assert_equal(hash.timestamps.keys.sort, @twitter.get(:Users, key).timestamps.keys.sort)
+    assert_equal(hash.timestamps.keys.sort, @twitter.get(:Users, key).timestamps.keys)
     assert_not_equal(hash.keys, @twitter.get(:Users, key).keys)
   end
 
@@ -190,24 +190,79 @@ class CassandraTest < Test::Unit::TestCase
     assert_nil @twitter.get(:StatusRelationships, 'bogus', 'user_timelines', columns.keys.first)
   end
 
+  def test_get_range_with_key_range
+    skip('This test requires the use of OrderPreservingPartitioner on the cluster to work properly.')
+    k = key
+    @twitter.insert(:Statuses, k + '2', {'body' => '1'})
+    @twitter.insert(:Statuses, k + '3', {'body' => '1'})
+    @twitter.insert(:Statuses, k + '4', {'body' => '1'})
+    @twitter.insert(:Statuses, k + '5', {'body' => '1'})
+    @twitter.insert(:Statuses, k + '6', {'body' => '1'})
+    assert_equal([k + '3', k + '4', k + '5'], @twitter.get_range(:Statuses, :start_key => k + '3', :finish_key => k + '5').keys)
+  end
 
-  #TODO: add a OPP keyspace for this
-  # def test_get_range
-  #   @twitter.insert(:Statuses, '2', {'body' => '1'})
-  #   @twitter.insert(:Statuses, '3', {'body' => '1'})
-  #   @twitter.insert(:Statuses, '4', {'body' => '1'})
-  #   @twitter.insert(:Statuses, '5', {'body' => '1'})
-  #   @twitter.insert(:Statuses, '6', {'body' => '1'})
-  #   assert_equal(['3', '4', '5'], @twitter.get_range(:Statuses, :start => '3', :finish => '5'))
-  # end
+  def test_get_range
+    # make sure that deleted rows are not included in the iteration
+    10.times do |i|
+      @twitter.insert(:Statuses, i.to_s, {'body' => '1'})
+      @twitter.insert(:Statuses, i.to_s + '_delete_me', {'test' => 'value'})
+      @twitter.remove(:Statuses, i.to_s + '_delete_me')
+    end
 
-  def test_get_range_count
-     @twitter.insert(:Statuses, '2', {'body' => '1'})
-     @twitter.insert(:Statuses, '3', {'body' => '1'})
-     @twitter.insert(:Statuses, '4', {'body' => '1'})
-     @twitter.insert(:Statuses, '5', {'body' => '1'})
-     @twitter.insert(:Statuses, '6', {'body' => '1'})
-     assert_equal(3, @twitter.get_range(:Statuses, :count => 3).size)
+    assert_equal(4, @twitter.get_range_keys(:Statuses, :key_count => 4).size)
+  end
+
+  def test_each_key
+    k = key
+    keys_yielded = []
+
+    10.times do |i|
+      @twitter.insert(:Statuses, k + i.to_s, {"body-#{i.to_s}" => 'v'})
+    end
+
+    # make sure that deleted rows are not included in the iteration
+    @twitter.insert(:Statuses, k + '_delete_me', {'test' => 'value'})
+    @twitter.remove(:Statuses, k + '_delete_me')
+
+    @twitter.each_key(:Statuses) do |key|
+      keys_yielded << key
+    end
+
+    assert_equal 10, keys_yielded.length
+  end
+
+  def test_each
+    k = key
+    key_columns  = {}
+
+    10.times do |i|
+      key_columns[k + i.to_s]   = {"body-#{i.to_s}" => 'v', 'single_column_lookup' => "value = #{i.to_s}"}
+      @twitter.insert(:Statuses, k + i.to_s, key_columns[k + i.to_s])
+    end
+
+    keys_yielded = []
+    @twitter.each(:Statuses, :batch_size => 5) do |key, columns|
+      assert_equal key_columns[key], columns
+      keys_yielded << key
+    end
+
+    assert_equal 10, keys_yielded.length
+
+    keys_yielded = []
+    @twitter.each(:Statuses, :key_count => 7, :batch_size => 5) do |key, columns|
+      assert_equal key_columns[key], columns
+      keys_yielded << key
+    end
+
+    assert_equal 7, keys_yielded.length, 'each limits to specified count'
+
+    keys_yielded = []
+    @twitter.each(:Statuses, :columns => ['single_column_lookup'], :batch_size => 5) do |key, columns|
+      assert_equal key_columns[key].reject {|k,v| k != 'single_column_lookup'}, columns
+      keys_yielded << key
+    end
+
+    assert_equal 10, keys_yielded.length
   end
 
   def test_multi_get
@@ -329,9 +384,10 @@ class CassandraTest < Test::Unit::TestCase
   end
 
   def test_count_keys
-    @twitter.insert(:Statuses, key + "1", {'body' => '1'})
-    @twitter.insert(:Statuses, key + "2", {'body' => '2'})
-    @twitter.insert(:Statuses, key + "3", {'body' => '3'})
+    k = key
+    @twitter.insert(:Statuses, k + "1", {'body' => '1'})
+    @twitter.insert(:Statuses, k + "2", {'body' => '2'})
+    @twitter.insert(:Statuses, k + "3", {'body' => '3'})
     assert_equal 3, @twitter.count_range(:Statuses)
   end
 

data/test/test_helper.rb

@@ -1,4 +1,4 @@
-CASSANDRA_VERSION = ENV['CASSANDRA_VERSION'] || '0.7'
+CASSANDRA_VERSION ||= ENV['CASSANDRA_VERSION'] || '0.7'
 
 require 'test/unit'
 require "#{File.expand_path(File.dirname(__FILE__))}/../lib/cassandra/#{CASSANDRA_VERSION}"
@@ -9,7 +9,7 @@ begin
 rescue Thrift::TransportException => e
   #FIXME Make server automatically start if not running
   if e.message =~ /Could not connect/
-    puts "*** Please start the Cassandra server by running 'rake cassandra'. ***" 
+    puts "*** Please start the Cassandra server by running 'rake cassandra'. ***"
     exit 1
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cassandra
 version: !ruby/object:Gem::Version 
-  hash: 55
+  hash: 51
   prerelease: 
   segments: 
   - 0
-  - 10
+  - 11
   - 0
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors: 
 - Evan Weaver, Ryan King
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-28 00:00:00 Z
+date: 2011-05-18 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: thrift_client