cassandra 0.11.0 → 0.11.1

data/lib/cassandra/columns.rb

@@ -5,15 +5,15 @@ class Cassandra
     private
 
     def is_super(column_family)
-      @is_super[column_family] ||= column_family_property(column_family, 'Type') == "Super"
+      @is_super[column_family] ||= column_family_property(column_family, 'column_type') == "Super"
     end
 
     def column_name_class(column_family)
-      @column_name_class[column_family] ||= column_name_class_for_key(column_family, "CompareWith")
+      @column_name_class[column_family] ||= column_name_class_for_key(column_family, "comparator_type")
     end
 
     def sub_column_name_class(column_family)
-      @sub_column_name_class[column_family] ||= column_name_class_for_key(column_family, "CompareSubcolumnsWith")
+      @sub_column_name_class[column_family] ||= column_name_class_for_key(column_family, "subcomparator_type")
     end
 
     def column_name_class_for_key(column_family, comparator_key)
@@ -28,10 +28,11 @@ class Cassandra
     end
 
     def column_family_property(column_family, key)
-      unless schema[column_family]
+      cfdef = schema.cf_defs.find {|cfdef| cfdef.name == column_family }
+      unless cfdef
         raise AccessError, "Invalid column family \"#{column_family}\""
       end
-      schema[column_family][key]
+      cfdef.send(key)
     end
 
     def multi_key_slices_to_hash(column_family, array, return_empty_rows = false)
@@ -72,16 +73,72 @@ class Cassandra
     def columns_to_hash_for_classes(columns, column_name_class, sub_column_name_class = nil)
       hash = OrderedHash.new
       Array(columns).each do |c|
-        c = c.super_column || c.column if c.is_a?(CassandraThrift::ColumnOrSuperColumn)
+        c = c.super_column || c.column || c.counter_column if c.is_a?(CassandraThrift::ColumnOrSuperColumn)
         case c
         when CassandraThrift::SuperColumn
           hash.[]=(column_name_class.new(c.name), columns_to_hash_for_classes(c.columns, sub_column_name_class)) # Pop the class stack, and recurse
         when CassandraThrift::Column
           hash.[]=(column_name_class.new(c.name), c.value, c.timestamp)
+        when CassandraThrift::CounterColumn
+          hash.[]=(column_name_class.new(c.name), c.value, 0)
         end
       end
       hash
     end
 
+    def _standard_insert_mutation(column_family, column_name, value, timestamp, ttl = nil)
+      CassandraThrift::Mutation.new(
+        :column_or_supercolumn => CassandraThrift::ColumnOrSuperColumn.new(
+          :column => CassandraThrift::Column.new(
+            :name      => column_name_class(column_family).new(column_name).to_s,
+            :value     => value,
+            :timestamp => timestamp,
+            :ttl       => ttl
+          )
+        )
+      )
+    end
+
+    def _super_insert_mutation(column_family, super_column_name, sub_columns, timestamp, ttl = nil)
+      CassandraThrift::Mutation.new(:column_or_supercolumn => 
+        CassandraThrift::ColumnOrSuperColumn.new(
+          :super_column => CassandraThrift::SuperColumn.new(
+            :name => column_name_class(column_family).new(super_column_name).to_s,
+            :columns => sub_columns.collect { |sub_column_name, sub_column_value|
+              CassandraThrift::Column.new(
+                :name      => sub_column_name_class(column_family).new(sub_column_name).to_s,
+                :value     => sub_column_value.to_s,
+                :timestamp => timestamp,
+                :ttl       => ttl
+              )
+            }
+          )
+        )
+      )
+    end
+
+    # General info about a deletion object within a mutation
+    # timestamp - required. If this is the only param, it will cause deletion of the whole key at that TS
+    # supercolumn - opt. If passed, the deletes will only occur within that supercolumn (only subcolumns 
+    #               will be deleted). Otherwise the normal columns will be deleted.
+    # predicate - opt. Defines how to match the columns to delete. if supercolumn passed, the slice will 
+    #               be scoped to subcolumns of that supercolumn.
+    
+    # Deletes a single column from the containing key/CF (and possibly supercolumn), at a given timestamp. 
+    # Although mutations (as opposed to 'remove' calls) support deleting slices and lists of columns in one shot, this is not implemented here.
+    # The main reason being that the batch function takes removes, but removes don't have that capability...so we'd need to change the remove
+    # methods to use delete mutation calls...although that might have performance implications. We'll leave that refactoring for later.
+    def _delete_mutation(cf, column, subcolumn, timestamp, options={})
+      deletion_hash = {:timestamp => timestamp}
+      if is_super(cf)
+        deletion_hash[:super_column] = column if column
+        deletion_hash[:predicate] = CassandraThrift::SlicePredicate.new(:column_names => [subcolumn]) if subcolumn
+      else
+        deletion_hash[:predicate] = CassandraThrift::SlicePredicate.new(:column_names => [column]) if column
+      end
+      CassandraThrift::Mutation.new(
+        :deletion => CassandraThrift::Deletion.new(deletion_hash)
+      )
+    end
   end
 end

data/lib/cassandra/mock.rb

@@ -34,6 +34,14 @@ class Cassandra
       @data[column_family.to_sym] = OrderedHash.new
     end
 
+    def default_write_consistency=(value)
+      WRITE_DEFAULTS[:consistency] = value
+    end
+
+    def default_read_consistency=(value)
+      READ_DEFAULTS[:consistency] = value
+    end
+
     def insert(column_family, key, hash_or_array, options = {})
       if @batch
         @batch << [:insert, column_family, key, hash_or_array, options]
@@ -118,8 +126,11 @@ class Cassandra
       end
     end
 
-    def exists?(column_family, key, column=nil)
-      !!get(column_family, key, column)
+    def exists?(column_family, key, *columns_and_options)
+      column_family, column, sub_column, options = extract_and_validate_params_for_real(column_family, [key], columns_and_options, READ_DEFAULTS)
+      results = get(column_family, key, column, sub_column)
+
+      ![{}, nil].include?(results)
     end
 
     def multi_get(column_family, keys, *columns_and_options)
@@ -258,21 +269,28 @@ class Cassandra
       end
     end
 
-    def create_idx_expr(c_name, value, op)
+    def create_index_expression(c_name, value, op)
       {:column_name => c_name, :value => value, :comparison => op}
     end
+    alias :create_idx_expr :create_index_expression
 
-    def create_idx_clause(idx_expressions, start = "")
-      {:start => start, :index_expressions => idx_expressions}
+    def create_index_clause(idx_expressions, start = "", count = 100)
+      {:start => start, :index_expressions => idx_expressions, :count => count, :type => :index_clause}
     end
+    alias :create_idx_clause :create_index_clause
 
     def get_indexed_slices(column_family, idx_clause, *columns_and_options)
       column_family, columns, _, options =
-        extract_and_validate_params_for_real(column_family, [], columns_and_options, READ_DEFAULTS)
+        extract_and_validate_params_for_real(column_family, [], columns_and_options, READ_DEFAULTS.merge(:key_count => 100, :key_start => ""))
+
+      unless [Hash, OrderedHash].include?(idx_clause.class) && idx_clause[:type] == :index_clause
+        idx_clause = create_index_clause(idx_clause, options[:key_start], options[:key_count])
+      end
 
       ret = {}
       cf(column_family).each do |key, row|
         next if idx_clause[:start] != '' && key < idx_clause[:start]
+        next if ret.length == idx_clause[:count]
 
         matches = []
         idx_clause[:index_expressions].each do |expr|
@@ -288,6 +306,23 @@ class Cassandra
       ret
     end
 
+    def add(column_family, key, value, *columns_and_options)
+      column_family, column, sub_column, options = extract_and_validate_params_for_real(column_family, key, columns_and_options, WRITE_DEFAULTS)
+
+      if is_super(column_family)
+        cf(column_family)[key]                      ||= OrderedHash.new
+        cf(column_family)[key][column]              ||= OrderedHash.new
+        cf(column_family)[key][column][sub_column]  ||= 0
+        cf(column_family)[key][column][sub_column]  += value
+      else
+        cf(column_family)[key]                      ||= OrderedHash.new
+        cf(column_family)[key][column]              ||= 0
+        cf(column_family)[key][column]              += value
+      end
+
+      nil
+    end
+
     def schema(load=true)
       @schema
     end
@@ -310,9 +345,11 @@ class Cassandra
         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;}
+            #ret[key] = columns.inject(OrderedHash.new){|hash, column_name| hash[column_name] = cf(column_family)[key][column_name]; hash;}
+            ret[key] = columns_to_hash(column_family, cf(column_family)[key].select{|k,v| columns.include?(k)})
           else
-            ret[key] = apply_range(cf(column_family)[key], column_family, start, finish, !is_super(column_family))
+            #ret[key] = apply_range(cf(column_family)[key], column_family, start, finish, !is_super(column_family))
+            ret[key] = apply_range(columns_to_hash(column_family, cf(column_family)[key]), column_family, start, finish)
           end
         end
       end

data/lib/cassandra/protocol.rb

@@ -0,0 +1,119 @@
+class Cassandra
+  # Inner methods for actually doing the Thrift calls
+  module Protocol #:nodoc:
+    private
+
+    def _mutate(mutation_map, consistency_level)
+      client.batch_mutate(mutation_map, consistency_level)
+    end
+
+    def _remove(key, column_path, timestamp, consistency_level)
+      client.remove(key, column_path, timestamp, consistency_level)
+    end
+
+    # FIXME: Add support for start, stop, count
+    def _count_columns(column_family, key, super_column, consistency)
+      client.get_count(key,
+        CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => super_column),
+        CassandraThrift::SlicePredicate.new(:slice_range =>
+                                            CassandraThrift::SliceRange.new(
+                                              :start => '',
+                                              :finish => ''
+                                            )),
+        consistency
+      )
+    end
+
+    # FIXME: Add support for start, stop, count
+    def _get_columns(column_family, key, columns, sub_columns, consistency)
+      result = if is_super(column_family)
+        if sub_columns
+          columns_to_hash(column_family, client.get_slice(key,
+            CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => columns),
+            CassandraThrift::SlicePredicate.new(:column_names => sub_columns),
+            consistency))
+        else
+          columns_to_hash(column_family, client.get_slice(key,
+            CassandraThrift::ColumnParent.new(:column_family => column_family),
+            CassandraThrift::SlicePredicate.new(:column_names => columns),
+            consistency))
+        end
+      else
+        columns_to_hash(column_family, client.get_slice(key,
+          CassandraThrift::ColumnParent.new(:column_family => column_family),
+          CassandraThrift::SlicePredicate.new(:column_names => columns),
+          consistency))
+      end
+
+      klass = column_name_class(column_family)
+      (sub_columns || columns).map { |name| result[klass.new(name)] }
+    end
+
+    def _multiget(column_family, keys, column, sub_column, count, start, finish, reversed, consistency)
+      # Single values; count and range parameters have no effect
+      if is_super(column_family) and sub_column
+        predicate = CassandraThrift::SlicePredicate.new(:column_names => [sub_column])
+        column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => column)
+        column_hash = multi_sub_columns_to_hash!(column_family, client.multiget_slice(keys, column_parent, predicate, consistency))
+
+        klass = sub_column_name_class(column_family)
+        keys.inject({}){|hash, key| hash[key] = column_hash[key][klass.new(sub_column)]; hash}
+      elsif !is_super(column_family) and column
+        predicate = CassandraThrift::SlicePredicate.new(:column_names => [column])
+        column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+        column_hash  = multi_columns_to_hash!(column_family, client.multiget_slice(keys, column_parent, predicate, consistency))
+
+        klass = column_name_class(column_family)
+        keys.inject({}){|hash, key| hash[key] = column_hash[key][klass.new(column)]; hash}
+
+      # Slices
+      else
+        predicate = CassandraThrift::SlicePredicate.new(:slice_range =>
+          CassandraThrift::SliceRange.new(
+            :reversed => reversed,
+            :count => count,
+            :start => start,
+            :finish => finish))
+
+        if is_super(column_family) and column
+          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => column)
+          multi_sub_columns_to_hash!(column_family, client.multiget_slice(keys, column_parent, predicate, consistency))
+        else
+          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+          multi_columns_to_hash!(column_family, client.multiget_slice(keys, column_parent, predicate, consistency))
+        end
+      end
+    end
+
+    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 = 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
+    def _get_indexed_slices(column_family, index_clause, column, count, start, finish, reversed, consistency)
+      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+      if column
+        predicate = CassandraThrift::SlicePredicate.new(:column_names => [column])
+      else
+        predicate = CassandraThrift::SlicePredicate.new(:slice_range =>
+          CassandraThrift::SliceRange.new(
+            :reversed => reversed,
+            :count => count,
+            :start => start,
+            :finish => finish))
+      end
+      client.get_indexed_slices(column_parent, index_clause, predicate, consistency)
+    end
+  end
+end

data/test/cassandra_mock_test.rb

@@ -17,6 +17,9 @@ class CassandraMockTest < CassandraTest
     @blogs_long = Cassandra::Mock.new('MultiblogLong', @test_schema)
     @blogs_long.clear_keyspace!
 
+    @type_conversions = Cassandra::Mock.new('TypeConversions', @test_schema)
+    @type_conversions.clear_keyspace!
+
     @uuids = (0..6).map {|i| SimpleUUID::UUID.new(Time.at(2**(24+i))) }
     @longs = (0..6).map {|i| Long.new(Time.at(2**(24+i))) }
   end

data/test/cassandra_test.rb

@@ -4,15 +4,21 @@ class CassandraTest < Test::Unit::TestCase
   include Cassandra::Constants
 
   def setup
-    @twitter = Cassandra.new('Twitter', "127.0.0.1:9160", :retries => 2, :exception_classes => [])
+    @twitter = Cassandra.new('Twitter', "127.0.0.1:9160", :retries => 2, :connect_timeout => 1, :exception_classes => [])
     @twitter.clear_keyspace!
 
-    @blogs = Cassandra.new('Multiblog', "127.0.0.1:9160",:retries => 2, :exception_classes => [])
+    @blogs = Cassandra.new('Multiblog', "127.0.0.1:9160", :retries => 2, :connect_timeout => 1, :exception_classes => [])
     @blogs.clear_keyspace!
 
-    @blogs_long = Cassandra.new('MultiblogLong', "127.0.0.1:9160",:retries => 2, :exception_classes => [])
+    @blogs_long = Cassandra.new('MultiblogLong', "127.0.0.1:9160", :retries => 2, :connect_timeout => 1, :exception_classes => [])
     @blogs_long.clear_keyspace!
 
+    @type_conversions = Cassandra.new('TypeConversions', "127.0.0.1:9160", :retries => 2, :connect_timeout => 1, :exception_classes => [])
+    @type_conversions.clear_keyspace!
+
+    Cassandra::WRITE_DEFAULTS[:consistency] = Cassandra::Consistency::ONE
+    Cassandra::READ_DEFAULTS[:consistency]  = Cassandra::Consistency::ONE
+
     @uuids = (0..6).map {|i| SimpleUUID::UUID.new(Time.at(2**(24+i))) }
     @longs = (0..6).map {|i| Long.new(Time.at(2**(24+i))) }
   end
@@ -24,13 +30,37 @@ class CassandraTest < Test::Unit::TestCase
     end
   end
 
+  def test_setting_default_consistency
+    assert_nothing_raised do
+      @twitter.default_read_consistency = Cassandra::Consistency::ALL
+    end
+    assert_equal(Cassandra::READ_DEFAULTS[:consistency], Cassandra::Consistency::ALL)
+
+    assert_nothing_raised do
+      @twitter.default_write_consistency = Cassandra::Consistency::ALL
+    end
+    assert_equal(Cassandra::WRITE_DEFAULTS[:consistency], Cassandra::Consistency::ALL)
+  end
+
   def test_get_key
+    
     @twitter.insert(:Users, key, {'body' => 'v', 'user' => 'v'})
     assert_equal({'body' => 'v', 'user' => 'v'}, @twitter.get(:Users, key))
     assert_equal(['body', 'user'].sort, @twitter.get(:Users, key).timestamps.keys.sort)
     assert_equal({}, @twitter.get(:Users, 'bogus'))
   end
 
+  def test_get_single_column_returns_single_value
+    @twitter.insert(:Users, key, {'body' => 'body_text', 'user' => 'user_name'})
+    assert_equal('body_text', @twitter.get(:Users, key, 'body'))
+    assert_equal('user_name', @twitter.get(:Users, key, 'user'))
+
+    @blogs.insert(:Blogs, key,
+      {@uuids[0] => 'I like this cat', @uuids[1] => 'Buttons is cuter', @uuids[2] => 'I disagree'})
+
+    assert_equal('I like this cat', @blogs.get(:Blogs, key, @uuids[0]))
+  end
+
   def test_get_key_preserving_order
     # In-order hash is preserved
     hash = OrderedHash['a', '', 'b', '', 'c', '', 'd', '',]
@@ -116,9 +146,25 @@ class CassandraTest < Test::Unit::TestCase
     assert_equal 5, @twitter.get(:Statuses, k, :start => "body-0", :finish => "body-4", :count => 7).length
   end
 
-  def test_exists_with_only_key
+  def test_exists
     @twitter.insert(:Statuses, key, {'body' => 'v'})
-    assert @twitter.exists?(:Statuses, key)
+    assert_equal true, @twitter.exists?(:Statuses, key)
+    assert_equal false, @twitter.exists?(:Statuses, 'bogus')
+
+    columns = {@uuids[1] => 'v1', @uuids[2] => 'v2'}
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => columns})
+
+    # verify return value when searching by key
+    assert_equal true, @twitter.exists?(:StatusRelationships, key)
+    assert_equal false, @twitter.exists?(:StatusRelationships, 'bogus')
+
+    # verify return value when searching by key and column
+    assert_equal true, @twitter.exists?(:StatusRelationships, key, 'user_timelines')
+    assert_equal false, @twitter.exists?(:StatusRelationships, key, 'bogus')
+
+    # verify return value when searching by key and column and subcolumn
+    assert_equal true, @twitter.exists?(:StatusRelationships, key, 'user_timelines', @uuids[1])
+    assert_equal false, @twitter.exists?(:StatusRelationships, key, 'user_timelines', @uuids[3])
   end
 
   def test_get_super_key
@@ -180,7 +226,7 @@ class CassandraTest < Test::Unit::TestCase
     assert_equal(columns.keys.sort, @twitter.get(:StatusRelationships, key, 'user_timelines').timestamps.keys.sort)
     assert_equal({}, @twitter.get(:StatusRelationships, 'bogus', 'user_timelines'))
     # FIXME Not sure if this is valid
-    # assert_nil @twitter.exists?(:StatusRelationships, 'bogus', 'user_timelines')
+    assert_equal false, @twitter.exists?(:StatusRelationships, 'bogus', 'user_timelines')
   end
 
   def test_get_super_value
@@ -190,16 +236,16 @@ 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
+#  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
 
   def test_get_range
     # make sure that deleted rows are not included in the iteration
@@ -524,6 +570,73 @@ class CassandraTest < Test::Unit::TestCase
     assert_equal({'user' => 'user'}, @twitter.get(:Users, k))
   end
 
+  def test_each_key
+    num_users = rand(60)
+    num_users.times do |twit_counter|
+      @twitter.insert(:Users, "Twitter : #{twit_counter}", {'body' => 'v1', 'user' => 'v1'})
+    end
+    counter = 0
+    @twitter.each_key(:Users) do |_, _|
+      counter += 1
+    end
+    assert_equal num_users, counter
+  end
+
+  def test_each_with_column_predicate
+    num_users = rand(60)
+    num_users.times do |twit_counter|
+      @twitter.insert(:Users, "Twitter : #{twit_counter}", {'body' => 'v1', 'user' => 'v1'})
+    end
+    counter = 0
+    @twitter.each(:Users, :batch_size => 10, :start => 'body', :finish => 'body') do |key, columns|
+      assert_equal 1, columns.length
+      counter += 1
+    end
+    assert_equal num_users, counter
+  end
+
+  def test_each_with_super_column
+    num_users = rand(50)
+    block_name = key
+    num_users.times do |twit_counter|
+      @twitter.insert(:StatusRelationships, block_name + twit_counter.to_s, {
+      'user_timelines' => {@uuids[1] => 'v1', @uuids[2] => 'v2'},
+      'mentions_timelines' => {@uuids[3] => 'v3'}})
+    end
+
+    counter = 0
+    # Restrict to one super column ::
+    @twitter.each(:StatusRelationships, :batch_size => 10, :start => 'user_timelines', :finish => 'user_timelines') do |key, columns|
+      columns.each do |_, column_value|
+          assert_equal 2, column_value.length
+      end
+      counter += 1
+    end
+
+    #Both super columns
+    @twitter.each(:StatusRelationships, :batch_size => 10, :start => 'mentions_timelines', :finish => 'user_timelines') do |key,columns|
+      assert_equal 2, columns.length
+      counter += 1
+    end
+
+    assert_equal num_users*2, counter
+
+  end
+
+  def test_each_column_types
+    num_users = rand(60)
+    num_users.times do |twit_counter|
+      @type_conversions.insert(:UUIDColumnConversion, twit_counter.to_s, {@uuids[1] => 'v1'})
+    end
+    counter = 0
+     @type_conversions.each(:UUIDColumnConversion) do |_, columns|
+      counter += 1
+      columns.keys.each {|column_name| assert_equal SimpleUUID::UUID, column_name.class}
+    end
+    assert_equal num_users, counter
+  end
+
+
   if CASSANDRA_VERSION.to_f >= 0.7
     def test_creating_and_dropping_new_index
       @twitter.create_index('Twitter', 'Statuses', 'column_name', 'LongType')
@@ -541,14 +654,83 @@ class CassandraTest < Test::Unit::TestCase
       @twitter.create_index('Twitter', 'Statuses', 'x', 'LongType')
 
       @twitter.insert(:Statuses, 'row1', { 'x' => [0,10].pack("NN")  })
-      @twitter.insert(:Statuses, 'row2', { 'x' => [0,20].pack("NN")  })
+
+      (2..10).to_a.each do |i|
+        @twitter.insert(:Statuses, 'row' + i.to_s, { 'x' => [0,20].pack("NN"), 'non_indexed' => [i].pack('N*') })
+      end
+
+      @twitter.insert(:Statuses, 'row11', { 'x' => [0,30].pack("NN")  })
+
+      expressions = [{:column_name => 'x', :value => [0,20].pack("NN"), :comparison => "=="}]
+
+      # verify multiples will be returned
+      assert_equal 9, @twitter.get_indexed_slices(:Statuses, expressions).length
+
+      # verify that GT and LT queries perform properly
+      expressions   =  [
+                          {:column_name => 'x',           :value => [0,20].pack("NN"),  :comparison => "=="},
+                          {:column_name => 'non_indexed', :value => [5].pack("N*"),     :comparison => ">"}
+                       ]
+      assert_equal(5, @twitter.get_indexed_slices(:Statuses, expressions).length)
+    end
+
+    def test_old_get_indexed_slices
+      @twitter.create_index('Twitter', 'Statuses', 'x', 'LongType')
+
+      @twitter.insert(:Statuses, 'row1', { 'x' => [0,10].pack("NN")  })
+
+      (2..10).to_a.each do |i|
+        @twitter.insert(:Statuses, 'row' + i.to_s, { 'x' => [0,20].pack("NN"), 'non_indexed' => [i].pack('N*') })
+      end
+
+      @twitter.insert(:Statuses, 'row11', { 'x' => [0,30].pack("NN")  })
 
       idx_expr   = @twitter.create_idx_expr('x', [0,20].pack("NN"), "==")
+
+      # verify count is observed
+      idx_clause = @twitter.create_idx_clause([idx_expr], "", 1)
+      assert_equal 1, @twitter.get_indexed_slices(:Statuses, idx_clause).length
+
+      # verify multiples will be returned
       idx_clause = @twitter.create_idx_clause([idx_expr])
+      assert_equal 9, @twitter.get_indexed_slices(:Statuses, idx_clause).length
+
+      # verify that GT and LT queries perform properly
+      idx_expr   =  [
+                      @twitter.create_idx_expr('x', [0,20].pack("NN"), "=="),
+                      @twitter.create_idx_expr('non_indexed', [5].pack("N*"), ">")
+                    ]
+      idx_clause = @twitter.create_idx_clause(idx_expr)
+      assert_equal(5, @twitter.get_indexed_slices(:Statuses, idx_clause).length)
+    end
+  end
+
+  if CASSANDRA_VERSION.to_f >= 0.8
+    def test_adding_getting_value_in_counter
+      assert_nil @twitter.add(:UserCounters, 'bob', 5, 'tweet_count')
+      assert_equal(5, @twitter.get(:UserCounters, 'bob', 'tweet_count'))
+      assert_nil @twitter.get(:UserCounters, 'bogus', 'tweet_count')
+    end
+
+    def test_get_counter_slice
+      assert_nil @twitter.add(:UserCounters, 'bob', 5, 'tweet_count')
+      assert_equal({'tweet_count' => 5}, @twitter.get(:UserCounters, 'bob', :start => "tweet_count", :finish => "tweet_count"))
+    end
+
+    def test_adding_getting_value_in_multiple_counters
+      assert_nil @twitter.add(:UserCounters, 'bob', 5, 'tweet_count')
+      assert_nil @twitter.add(:UserCounters, 'bob', 7, 'follower_count')
+      assert_equal(5, @twitter.get(:UserCounters, 'bob', 'tweet_count'))
+      assert_nil @twitter.get(:UserCounters, 'bogus', 'tweet_count')
+      assert_equal([5, 7], @twitter.get_columns(:UserCounters, 'bob', ['tweet_count', 'follower_count']))
+      assert_equal([5, 7, nil], @twitter.get_columns(:UserCounters, 'bob', ['tweet_count', 'follower_count', 'bogus']))
+    end
 
-      indexed_row = @twitter.get_indexed_slices(:Statuses, idx_clause)
-      assert_equal(1,      indexed_row.length)
-      assert_equal('row2', indexed_row.keys.first)
+    def test_adding_getting_value_in_multiple_counters_with_super_columns
+      assert_nil @twitter.add(:UserCounterAggregates, 'bob', 1, 'DAU', 'today')
+      assert_nil @twitter.add(:UserCounterAggregates, 'bob', 2, 'DAU', 'tomorrow')
+      assert_equal(1, @twitter.get(:UserCounterAggregates, 'bob', 'DAU', 'today'))
+      assert_equal(2, @twitter.get(:UserCounterAggregates, 'bob', 'DAU', 'tomorrow'))
     end
   end