cassandra 0.13.0 → 0.14.0

data/lib/cassandra/columns.rb

@@ -16,12 +16,37 @@ class Cassandra
       @sub_column_name_class[column_family] ||= column_name_class_for_key(column_family, "subcomparator_type")
     end
 
+    def column_name_maker(column_family)
+      @column_name_maker[column_family] ||=
+        begin
+          klass = column_name_class(column_family)
+          if klass == Composite
+            lambda {|name| klass.new_from_packed(name) }
+          else
+            lambda {|name| klass.new(name) }
+          end
+        end
+    end
+
+    def sub_column_name_maker(column_family)
+      @sub_column_name_maker[column_family] ||=
+        begin
+          klass = sub_column_name_class(column_family)
+          if klass == Composite
+            lambda {|name| klass.new_from_packed(name) }
+          else
+            lambda {|name| klass.new(name) }
+          end
+        end
+    end
+
     def column_name_class_for_key(column_family, comparator_key)
       property = column_family_property(column_family, comparator_key)
       property =~ /[^(]*\.(.*?)$/
       case $1
       when "LongType" then Long
       when "LexicalUUIDType", "TimeUUIDType" then SimpleUUID::UUID
+      when /^DynamicCompositeType\(/ then DynamicComposite
       when /^CompositeType\(/ then Composite
       else
         String # UTF8, Ascii, Bytes, anything else
@@ -64,26 +89,26 @@ class Cassandra
     end
 
     def columns_to_hash(column_family, columns)
-      columns_to_hash_for_classes(columns, column_name_class(column_family), sub_column_name_class(column_family))
+      columns_to_hash_for_classes(columns, column_name_maker(column_family), sub_column_name_maker(column_family))
     end
 
     def sub_columns_to_hash(column_family, columns)
-      columns_to_hash_for_classes(columns, sub_column_name_class(column_family))
+      columns_to_hash_for_classes(columns, sub_column_name_maker(column_family))
     end
 
-    def columns_to_hash_for_classes(columns, column_name_class, sub_column_name_class = nil)
+    def columns_to_hash_for_classes(columns, column_name_maker, sub_column_name_maker = nil)
       hash = OrderedHash.new
       Array(columns).each do |c|
         c = c.super_column || c.column || c.counter_column || c.counter_super_column if c.is_a?(CassandraThrift::ColumnOrSuperColumn)
         case c
-        when CassandraThrift::CounterSuperColumn
-          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::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
+          hash.[]=(column_name_maker.call(c.name), columns_to_hash_for_classes(c.columns, sub_column_name_maker)) # Pop the class stack, and recurse
         when CassandraThrift::Column
-          hash.[]=(column_name_class.new(c.name), c.value, c.timestamp)
+          hash.[]=(column_name_maker.call(c.name), c.value, c.timestamp)
         when CassandraThrift::CounterColumn
-          hash.[]=(column_name_class.new(c.name), c.value, 0)
+          hash.[]=(column_name_maker.call(c.name), c.value, 0)
+        when CassandraThrift::CounterSuperColumn
+          hash.[]=(column_name_maker.call(c.name), columns_to_hash_for_classes(c.columns, sub_column_name_maker)) # Pop the class stack, and recurse
         end
       end
       hash
@@ -103,7 +128,7 @@ class Cassandra
     end
 
     def _super_insert_mutation(column_family, super_column_name, sub_columns, timestamp, ttl = nil)
-      CassandraThrift::Mutation.new(:column_or_supercolumn => 
+      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,
@@ -122,12 +147,12 @@ class Cassandra
 
     # 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 
+    # 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 
+    # 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. 
+
+    # 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.

data/lib/cassandra/composite.rb

@@ -1,4 +1,3 @@
-
 class Cassandra
   class Composite
     include ::Comparable
@@ -6,6 +5,8 @@ class Cassandra
     attr_reader :column_slice
 
     def initialize(*parts)
+      return if parts.empty?
+
       options = {}
       if parts.last.is_a?(Hash)
         options = parts.pop
@@ -16,13 +17,19 @@ class Cassandra
       if parts.length == 1 && parts[0].instance_of?(self.class)
         @column_slice = parts[0].column_slice
         @parts = parts[0].parts
-      elsif parts.length == 1 && parts[0].instance_of?(String) && @column_slice.nil? && valid_packed_composite?(parts[0])
-        unpack(parts[0])
+      elsif parts.length == 1 && parts[0].instance_of?(String) && @column_slice.nil? && try_packed_composite(parts[0])
+        @hash = parts[0].hash
       else
         @parts = parts
       end
     end
 
+    def self.new_from_packed(packed)
+      obj = new
+      obj.fast_unpack(packed)
+      return obj
+    end
+
     def [](*args)
       return @parts[*args]
     end
@@ -67,7 +74,7 @@ class Cassandra
     end
 
     def inspect
-      return "#<Composite:#{@column_slice} #{@parts.inspect}>"
+      return "#<#{self.class}:#{@column_slice} #{@parts.inspect}>"
     end
 
     def slice_end_of_component
@@ -76,27 +83,31 @@ class Cassandra
       return "\x00"
     end
 
-    private
-    def unpack(packed_string)
-      parts = []
-      end_of_component = nil
+    def fast_unpack(packed_string)
+      @hash = packed_string.hash
+
+      @parts = []
+      end_of_component = packed_string.slice(packed_string.length-1, 1)
       while packed_string.length > 0
-        length = packed_string.slice(0, 2).unpack('n')[0]
-        parts << packed_string.slice(2, length)
-        end_of_component = packed_string.slice(2 + length, 1)
+        length = packed_string.unpack('n')[0]
+        @parts << packed_string.slice(2, length)
 
-        packed_string = packed_string.slice(3 + length, packed_string.length)
+        packed_string.slice!(0, length+3)
       end
+
       @column_slice = :after if end_of_component == "\x01"
       @column_slice = :before if end_of_component == "\xFF"
-      @parts = parts
     end
 
-    def valid_packed_composite?(packed_string)
+    private
+    def try_packed_composite(packed_string)
+      parts = []
+      end_of_component = nil
       while packed_string.length > 0
         length = packed_string.slice(0, 2).unpack('n')[0]
         return false if length.nil? || length + 3 > packed_string.length
 
+        parts << packed_string.slice(2, length)
         end_of_component = packed_string.slice(2 + length, 1)
         if length + 3 != packed_string.length
           return false if end_of_component != "\x00"
@@ -104,11 +115,16 @@ class Cassandra
 
         packed_string = packed_string.slice(3 + length, packed_string.length)
       end
+
+      @column_slice = :after if end_of_component == "\x01"
+      @column_slice = :before if end_of_component == "\xFF"
+      @parts = parts
+
       return true
     end
 
     def hash
-      return to_s.hash
+      return @hash ||= pack.hash
     end
 
     def eql?(other)
@@ -116,3 +132,9 @@ class Cassandra
     end
   end
 end
+
+begin
+  require "cassandra_native"
+rescue LoadError
+  puts "Unable to load cassandra_native extension. Defaulting to pure Ruby libraries."
+end

data/lib/cassandra/dynamic_composite.rb

@@ -0,0 +1,96 @@
+class Cassandra
+  class DynamicComposite < Composite
+    attr_accessor :types
+
+    def initialize(*parts)
+      return if parts.empty?
+
+      options = {}
+      if parts.last.is_a?(Hash)
+        options = parts.pop
+      end
+      @column_slice = options[:slice]
+      raise ArgumentError if @column_slice != nil && ![:before, :after].include?(@column_slice)
+
+      if parts.length == 1 && parts[0].instance_of?(self.class)
+        @column_slice = parts[0].column_slice
+        @parts = parts[0].parts
+        @types = parts[0].types
+      elsif parts.length == 1 && parts[0].instance_of?(String) && @column_slice.nil? && try_packed_composite(parts[0])
+        @hash = parts[0].hash
+      else
+        @types, @parts = parts.transpose
+      end
+    end
+
+    def pack
+      packed_parts = @parts.map do |part|
+        [part.length].pack('n') + part + "\x00"
+      end
+
+      if @column_slice
+        part = @parts[-1]
+        packed_parts[-1] = [part.length].pack('n') + part + slice_end_of_component
+      end
+
+      packed_types = @types.map do |type|
+        if type.length == 1
+          [0x8000 | type.ord].pack('n')
+        else
+          [type.length].pack('n') + type
+        end
+      end
+
+      return packed_types.zip(packed_parts).flatten.join('')
+    end
+
+    def fast_unpack(packed_string)
+      result = try_packed_composite(packed_string)
+      raise ArgumentError.new("Invalid DynamicComposite column") if !result
+      @hash = packed_string.hash
+    end
+
+    private
+    def try_packed_composite(packed_string)
+      types = []
+      parts = []
+      end_of_component = nil
+      offset = 0
+
+      read_bytes = proc do |length|
+        return false if offset + length > packed_string.length
+        out = packed_string.slice(offset, length)
+        offset += length
+        out
+      end
+
+      while offset < packed_string.length
+        header = read_bytes.call(2).unpack('n')[0]
+        is_alias = header & 0x8000 != 0
+        if is_alias
+          alias_char = (header & 0xFF).chr
+          types << alias_char
+        else
+          length = header
+          return false if length.nil? || length + offset > packed_string.length
+          type = read_bytes.call(length)
+          types << type
+        end
+        length = read_bytes.call(2).unpack('n')[0]
+        return false if length.nil? || length + offset > packed_string.length
+        parts << read_bytes.call(length)
+        end_of_component = read_bytes.call(1)
+        if offset < packed_string.length
+          return false if end_of_component != "\x00"
+        end
+      end
+      @column_slice = :after if end_of_component == "\x01"
+      @column_slice = :before if end_of_component == "\xFF"
+      @types = types
+      @parts = parts
+      @hash = packed_string.hash
+
+      return true
+    end
+  end
+end

data/lib/cassandra/mock.rb

@@ -20,6 +20,8 @@ class Cassandra
       @keyspace = keyspace
       @column_name_class = {}
       @sub_column_name_class = {}
+      @column_name_maker = {}
+      @sub_column_name_maker = {}
       @indexes = {}
       @schema = schema[keyspace]
       clear_keyspace!
@@ -293,10 +295,13 @@ class Cassandra
 
     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.merge(:key_count => 100, :key_start => ""))
+        extract_and_validate_params_for_real(column_family, [], columns_and_options,
+        READ_DEFAULTS.merge(:key_count => 100, :start_key => nil, :key_start => nil))
+
+      start_key = options[:start_key] || options[: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])
+        idx_clause = create_index_clause(idx_clause, start_key, options[:key_count])
       end
 
       ret = {}
@@ -319,20 +324,24 @@ class Cassandra
     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
+      if @batch
+        @batch << [:add, column_family, key, value, *columns_and_options]
       else
-        cf(column_family)[key]                      ||= OrderedHash.new
-        cf(column_family)[key][column]              ||= 0
-        cf(column_family)[key][column]              += value
-      end
+        column_family, column, sub_column, options = extract_and_validate_params_for_real(column_family, key, columns_and_options, WRITE_DEFAULTS)
 
-      nil
+        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
     end
 
     def column_families

data/test/cassandra_mock_test.rb

@@ -28,6 +28,12 @@ class CassandraMockTest < CassandraTest
       Cassandra::Composite.new([1].pack('N'), "elephant"),
       Cassandra::Composite.new([10].pack('N'), "kangaroo"),
     ]
+    @dynamic_composites = [
+      Cassandra::DynamicComposite.new(['i', [5].pack('N')], ['UTF8Type', "zebra"]),
+      Cassandra::DynamicComposite.new(['i', [5].pack('N')], ['UTF8Type', "aardvark"]),
+      Cassandra::DynamicComposite.new(['IntegerType', [1].pack('N')], ['s', "elephant"]),
+      Cassandra::DynamicComposite.new(['IntegerType', [10].pack('N')], ['s', "kangaroo"]),
+    ]
   end
 
   def test_setup

data/test/cassandra_test.rb

@@ -3,17 +3,21 @@ require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 class CassandraTest < Test::Unit::TestCase
   include Cassandra::Constants
 
+  def assert_has_keys(keys, hash)
+    assert_equal Set.new(keys), Set.new(hash.keys)
+  end
+
   def setup
-    @twitter = Cassandra.new('Twitter', "127.0.0.1:9160", :retries => 2, :connect_timeout => 0.1, :exception_classes => [])
+    @twitter = Cassandra.new('Twitter', "127.0.0.1:9160", :retries => 2, :connect_timeout => 0.1, :timeout => 5, :exception_classes => [])
     @twitter.clear_keyspace!
 
-    @blogs = Cassandra.new('Multiblog', "127.0.0.1:9160", :retries => 2, :connect_timeout => 0.1, :exception_classes => [])
+    @blogs = Cassandra.new('Multiblog', "127.0.0.1:9160", :retries => 2, :connect_timeout => 0.1, :timeout => 5, :exception_classes => [])
     @blogs.clear_keyspace!
 
-    @blogs_long = Cassandra.new('MultiblogLong', "127.0.0.1:9160", :retries => 2, :connect_timeout => 0.1, :exception_classes => [])
+    @blogs_long = Cassandra.new('MultiblogLong', "127.0.0.1:9160", :retries => 2, :connect_timeout => 0.1, :timeout => 5, :exception_classes => [])
     @blogs_long.clear_keyspace!
 
-    @type_conversions = Cassandra.new('TypeConversions', "127.0.0.1:9160", :retries => 2, :connect_timeout => 0.1, :exception_classes => [])
+    @type_conversions = Cassandra.new('TypeConversions', "127.0.0.1:9160", :retries => 2, :connect_timeout => 0.1, :timeout => 5, :exception_classes => [])
     @type_conversions.clear_keyspace!
 
     Cassandra::WRITE_DEFAULTS[:consistency] = Cassandra::Consistency::ONE
@@ -27,6 +31,12 @@ class CassandraTest < Test::Unit::TestCase
       Cassandra::Composite.new([1].pack('N'), "elephant"),
       Cassandra::Composite.new([10].pack('N'), "kangaroo"),
     ]
+    @dynamic_composites = [
+      Cassandra::DynamicComposite.new(['i', [5].pack('N')], ['UTF8Type', "zebra"]),
+      Cassandra::DynamicComposite.new(['i', [5].pack('N')], ['UTF8Type', "aardvark"]),
+      Cassandra::DynamicComposite.new(['IntegerType', [1].pack('N')], ['s', "elephant"]),
+      Cassandra::DynamicComposite.new(['IntegerType', [10].pack('N')], ['s', "kangaroo"]),
+    ]
   end
 
   def test_inspect
@@ -510,9 +520,8 @@ class CassandraTest < Test::Unit::TestCase
 
     @twitter.insert(:Statuses, key, columns)
     assert_equal 200, @twitter.count_columns(:Statuses, key, :count => 200)
-    assert_equal 100, @twitter.count_columns(:Statuses, key)
-    assert_equal 55, @twitter.count_columns(:Statuses, key, :count => 55)
-
+    assert_equal 100, @twitter.count_columns(:Statuses, key) if CASSANDRA_VERSION.to_f >= 0.8
+    assert_equal 55, @twitter.count_columns(:Statuses, key, :count => 55) if CASSANDRA_VERSION.to_f >= 0.8
   end
 
   def test_count_super_columns
@@ -562,7 +571,7 @@ class CassandraTest < Test::Unit::TestCase
       assert_equal({'body' => 'v1', 'user' => 'v1'}, @twitter.get(:Users, k + '1')) # Written
       assert_equal({}, @twitter.get(:Users, k + '2')) # Not yet written
       assert_equal({}, @twitter.get(:Statuses, k + '3')) # Not yet written
-      assert_equal({}, @twitter.get(:UserCounters, 'bob')) if CASSANDRA_VERSION.to_f >= 0.8 # Not yet written
+      assert_equal({}, @twitter.get(:UserCounters, 'bob')) if CASSANDRA_VERSION.to_f >= 0.8 # Written
 
       @twitter.remove(:Users, k + '1') # Full row
       assert_equal({'body' => 'v1', 'user' => 'v1'}, @twitter.get(:Users, k + '1')) # Not yet removed
@@ -715,69 +724,361 @@ class CassandraTest < Test::Unit::TestCase
 
   if CASSANDRA_VERSION.to_f >= 0.7
     def test_creating_and_dropping_new_index
-      @twitter.create_index('Twitter', 'Statuses', 'column_name', 'LongType')
-      assert_nil @twitter.create_index('Twitter', 'Statuses', 'column_name', 'LongType')
+      @twitter.create_index('Twitter', 'Statuses', 'column_name', 'BytesType')
+      assert_nil @twitter.create_index('Twitter', 'Statuses', 'column_name', 'BytesType')
 
       @twitter.drop_index('Twitter', 'Statuses', 'column_name')
       assert_nil @twitter.drop_index('Twitter', 'Statuses', 'column_name')
 
       # Recreating and redropping the same index should not error either.
-      @twitter.create_index('Twitter', 'Statuses', 'column_name', 'LongType')
+      @twitter.create_index('Twitter', 'Statuses', 'column_name', 'BytesType')
       @twitter.drop_index('Twitter', 'Statuses', 'column_name')
     end
 
     def test_get_indexed_slices
-      @twitter.create_index('Twitter', 'Statuses', 'x', 'LongType')
+      @twitter.insert(:Statuses, 'row_a', {
+        'tags' => 'a',
+        'y' => 'foo'
+      })
+      @twitter.insert(:Statuses, 'row_b', {
+        'tags' => 'b',
+        'y' => 'foo'
+      })
+      [1,2].each do |i|
+        @twitter.insert(:Statuses, "row_c_#{i}", {
+          'tags' => 'c',
+          'y' => 'a'
+        })
+      end
+      [3,4].each do |i|
+        @twitter.insert(:Statuses, "row_c_#{i}", {
+          'tags' => 'c',
+          'y' => 'b'
+        })
+      end
+      @twitter.insert(:Statuses, 'row_d', {
+        'tags' => 'd',
+        'y' => 'foo'
+      })
+      @twitter.insert(:Statuses, 'row_e', {
+        'tags' => 'e',
+        'y' => 'bar'
+      })
+
+      # Test == operator (single clause)
+      rows = @twitter.get_indexed_slices(:Statuses, [
+        {:column_name => 'tags',
+         :value => 'c',
+         :comparison => "=="}
+      ])
+      assert_has_keys %w[row_c_1 row_c_2 row_c_3 row_c_4], rows
+
+      # Test other operators
+      # Currently (as of Cassandra 1.1) you can't use anything but == as the
+      # primary query -- you must match on == first, and subsequent clauses are
+      # then applied as filters -- so that's what we are doing here.
+
+      # Test > operator
+      rows = @twitter.get_indexed_slices(:Statuses, [
+        {:column_name => 'tags',
+         :value => 'c',
+         :comparison => "=="},
+        {:column_name => 'y',
+         :value => 'a',
+         :comparison => ">"}
+      ])
+      assert_has_keys %w[row_c_3 row_c_4], rows
+
+      # Test >= operator
+      rows = @twitter.get_indexed_slices(:Statuses, [
+        {:column_name => 'tags',
+         :value => 'c',
+         :comparison => "=="},
+        {:column_name => 'y',
+         :value => 'a',
+         :comparison => ">="}
+      ])
+      assert_has_keys %w[row_c_1 row_c_2 row_c_3 row_c_4], rows
+
+      # Test < operator
+      rows = @twitter.get_indexed_slices(:Statuses, [
+        {:column_name => 'tags',
+         :value => 'c',
+         :comparison => "=="},
+        {:column_name => 'y',
+         :value => 'b',
+         :comparison => "<"}
+      ])
+      assert_has_keys %w[row_c_1 row_c_2], rows
+
+      # Test <= operator
+      rows = @twitter.get_indexed_slices(:Statuses, [
+        {:column_name => 'tags',
+         :value => 'c',
+         :comparison => "=="},
+        {:column_name => 'y',
+         :value => 'b',
+         :comparison => "<="}
+      ])
+      assert_has_keys %w[row_c_1 row_c_2 row_c_3 row_c_4], rows
+
+      # Test query on a non-indexed column
+      unless self.is_a?(CassandraMockTest)
+        assert_raises(CassandraThrift::InvalidRequestException) do
+          @twitter.get_indexed_slices(:Statuses, [
+            {:column_name => 'y',
+             :value => 'foo',
+             :comparison => "=="}
+          ])
+        end
+      end
 
-      @twitter.insert(:Statuses, 'row1', { 'x' => [0,10].pack("NN")  })
+      # Test start key
+      rows = @twitter.get_indexed_slices(:Statuses, [
+        {:column_name => 'tags',
+         :value => 'c',
+         :comparison => "=="},
+      ], :start_key => 'row_c_2')
+      assert_equal 'row_c_2', rows.keys.first
+      # <- can't test any keys after that since it's going to be random
+
+      # Test key_start option
+      rows = @twitter.get_indexed_slices(:Statuses, [
+        {:column_name => 'tags',
+         :value => 'c',
+         :comparison => "=="},
+      ], :key_start => 'row_c_2')
+      assert_equal 'row_c_2', rows.keys.first
+      # <- can't test any keys after that since it's going to be random
+
+      # Test key count
+      rows = @twitter.get_indexed_slices(:Statuses, [
+        {:column_name => 'tags',
+         :value => 'c',
+         :comparison => "=="}
+      ], :key_count => 2)
+      assert_equal 2, rows.length
+      # <- can't test which keys are present since it's going to be random
+    end
 
-      (2..10).to_a.each do |i|
-        @twitter.insert(:Statuses, 'row' + i.to_s, { 'x' => [0,20].pack("NN"), 'non_indexed' => [i].pack('N*') })
+    def test_get_indexed_slices_with_IndexClause_objects
+      @twitter.insert(:Statuses, 'row_a', {
+        'tags' => 'a',
+        'y' => 'foo'
+      })
+      @twitter.insert(:Statuses, 'row_b', {
+        'tags' => 'b',
+        'y' => 'foo'
+      })
+      [1,2].each do |i|
+        @twitter.insert(:Statuses, "row_c_#{i}", {
+          'tags' => 'c',
+          'y' => 'a'
+        })
+      end
+      [3,4].each do |i|
+        @twitter.insert(:Statuses, "row_c_#{i}", {
+          'tags' => 'c',
+          'y' => 'b'
+        })
+      end
+      @twitter.insert(:Statuses, 'row_d', {
+        'tags' => 'd',
+        'y' => 'foo'
+      })
+      @twitter.insert(:Statuses, 'row_e', {
+        'tags' => 'e',
+        'y' => 'bar'
+      })
+
+      # Test == operator (single clause)
+      index_clause = @twitter.create_index_clause([
+        @twitter.create_index_expression('tags', 'c', '==')
+      ])
+      rows = @twitter.get_indexed_slices(:Statuses, index_clause)
+      assert_has_keys %w[row_c_1 row_c_2 row_c_3 row_c_4], rows
+
+      # Test other operators
+      # Currently (as of Cassandra 1.1) you can't use anything but == as the
+      # primary query -- you must match on == first, and subsequent clauses are
+      # then applied as filters -- so that's what we are doing here.
+
+      # Test > operator
+      index_clause = @twitter.create_index_clause([
+        @twitter.create_index_expression('tags', 'c', '=='),
+        @twitter.create_index_expression('y', 'a', '>'),
+      ])
+      rows = @twitter.get_indexed_slices(:Statuses, index_clause)
+      assert_has_keys %w[row_c_3 row_c_4], rows
+
+      # Test >= operator
+      index_clause = @twitter.create_index_clause([
+        @twitter.create_index_expression('tags', 'c', '=='),
+        @twitter.create_index_expression('y', 'a', '>=')
+      ])
+      rows = @twitter.get_indexed_slices(:Statuses, index_clause)
+      assert_has_keys %w[row_c_1 row_c_2 row_c_3 row_c_4], rows
+
+      # Test < operator
+      index_clause = @twitter.create_index_clause([
+        @twitter.create_index_expression('tags', 'c', '=='),
+        @twitter.create_index_expression('y', 'b', '<')
+      ])
+      rows = @twitter.get_indexed_slices(:Statuses, index_clause)
+      assert_has_keys %w[row_c_1 row_c_2], rows
+
+      # Test <= operator
+      index_clause = @twitter.create_index_clause([
+        @twitter.create_index_expression('tags', 'c', '=='),
+        @twitter.create_index_expression('y', 'b', '<=')
+      ])
+      rows = @twitter.get_indexed_slices(:Statuses, index_clause)
+      assert_has_keys %w[row_c_1 row_c_2 row_c_3 row_c_4], rows
+
+      # Test query on a non-indexed column
+      unless self.is_a?(CassandraMockTest)
+        assert_raises(CassandraThrift::InvalidRequestException) do
+          index_clause = @twitter.create_index_clause([
+            @twitter.create_index_expression('y', 'foo', '==')
+          ])
+          @twitter.get_indexed_slices(:Statuses, index_clause)
+        end
       end
 
-      @twitter.insert(:Statuses, 'row11', { 'x' => [0,30].pack("NN")  })
+      # Test start key
+      index_clause = @twitter.create_index_clause([
+        @twitter.create_index_expression('tags', 'c', '==')
+      ], 'row_c_2')
+      rows = @twitter.get_indexed_slices(:Statuses, index_clause)
+      assert_equal 'row_c_2', rows.keys.first
+      # <- can't test any keys after that since it's going to be random
+
+      # Test key count
+      index_clause = @twitter.create_index_clause([
+        @twitter.create_index_expression('tags', 'c', '==')
+      ], "", 2)
+      rows = @twitter.get_indexed_slices(:Statuses, index_clause)
+      assert_equal 2, rows.length
+      # <- can't test which keys are present since it's going to be random
+    end
 
-      expressions = [{:column_name => 'x', :value => [0,20].pack("NN"), :comparison => "=="}]
+    def test_create_index_clause
+      return if self.is_a?(CassandraMockTest)
 
-      # verify multiples will be returned
-      assert_equal 9, @twitter.get_indexed_slices(:Statuses, expressions).length
+      ie = CassandraThrift::IndexExpression.new(
+        :column_name => 'foo',
+        :value => 'x',
+        :op => '=='
+      )
 
-      # 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)
+      ic = @twitter.create_index_clause([ie], 'aaa', 250)
+      assert_instance_of CassandraThrift::IndexClause, ic
+      assert_equal 'aaa', ic.start_key
+      assert_equal ie, ic.expressions[0]
+      assert_equal 250, ic.count
+
+      # test alias
+      ic = @twitter.create_idx_clause([ie], 'aaa', 250)
+      assert_instance_of CassandraThrift::IndexClause, ic
+      assert_equal 'aaa', ic.start_key
+      assert_equal ie, ic.expressions[0]
+      assert_equal 250, ic.count
     end
 
-    def test_old_get_indexed_slices
-      @twitter.create_index('Twitter', 'Statuses', 'x', 'LongType')
+    def test_create_index_expression
+      return if self.is_a?(CassandraMockTest)
 
-      @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*') })
+      # EQ operator
+      [nil, "EQ", "eq", "=="].each do |op|
+        ie = @twitter.create_index_expression('foo', 'x', op)
+        assert_instance_of CassandraThrift::IndexExpression, ie
+        assert_equal 'foo', ie.column_name
+        assert_equal 'x', ie.value
+        assert_equal CassandraThrift::IndexOperator::EQ, ie.op
+      end
+      # alias
+      [nil, "EQ", "eq", "=="].each do |op|
+        ie = @twitter.create_idx_expr('foo', 'x', op)
+        assert_instance_of CassandraThrift::IndexExpression, ie
+        assert_equal 'foo', ie.column_name
+        assert_equal 'x', ie.value
+        assert_equal CassandraThrift::IndexOperator::EQ, ie.op
       end
 
-      @twitter.insert(:Statuses, 'row11', { 'x' => [0,30].pack("NN")  })
+      # GTE operator
+      ["GTE", "gte", ">="].each do |op|
+        ie = @twitter.create_index_expression('foo', 'x', op)
+        assert_instance_of CassandraThrift::IndexExpression, ie
+        assert_equal 'foo', ie.column_name
+        assert_equal 'x', ie.value
+        assert_equal CassandraThrift::IndexOperator::GTE, ie.op
+      end
+      # alias
+      ["GTE", "gte", ">="].each do |op|
+        ie = @twitter.create_idx_expr('foo', 'x', op)
+        assert_instance_of CassandraThrift::IndexExpression, ie
+        assert_equal 'foo', ie.column_name
+        assert_equal 'x', ie.value
+        assert_equal CassandraThrift::IndexOperator::GTE, ie.op
+      end
 
-      idx_expr   = @twitter.create_idx_expr('x', [0,20].pack("NN"), "==")
+      # GT operator
+      ["GT", "gt", ">"].each do |op|
+        ie = @twitter.create_index_expression('foo', 'x', op)
+        assert_instance_of CassandraThrift::IndexExpression, ie
+        assert_equal 'foo', ie.column_name
+        assert_equal 'x', ie.value
+        assert_equal CassandraThrift::IndexOperator::GT, ie.op
+      end
+      # alias
+      ["GT", "gt", ">"].each do |op|
+        ie = @twitter.create_idx_expr('foo', 'x', op)
+        assert_instance_of CassandraThrift::IndexExpression, ie
+        assert_equal 'foo', ie.column_name
+        assert_equal 'x', ie.value
+        assert_equal CassandraThrift::IndexOperator::GT, ie.op
+      end
 
-      # verify count is observed
-      idx_clause = @twitter.create_idx_clause([idx_expr], "", 1)
-      assert_equal 1, @twitter.get_indexed_slices(:Statuses, idx_clause).length
+      # LTE operator
+      ["LTE", "lte", "<="].each do |op|
+        ie = @twitter.create_index_expression('foo', 'x', op)
+        assert_instance_of CassandraThrift::IndexExpression, ie
+        assert_equal 'foo', ie.column_name
+        assert_equal 'x', ie.value
+        assert_equal CassandraThrift::IndexOperator::LTE, ie.op
+      end
+      # alias
+      ["LTE", "lte", "<="].each do |op|
+        ie = @twitter.create_idx_expr('foo', 'x', op)
+        assert_instance_of CassandraThrift::IndexExpression, ie
+        assert_equal 'foo', ie.column_name
+        assert_equal 'x', ie.value
+        assert_equal CassandraThrift::IndexOperator::LTE, ie.op
+      end
 
-      # verify multiples will be returned
-      idx_clause = @twitter.create_idx_clause([idx_expr])
-      assert_equal 9, @twitter.get_indexed_slices(:Statuses, idx_clause).length
+      # LT operator
+      ["LT", "lt", "<"].each do |op|
+        ie = @twitter.create_index_expression('foo', 'x', op)
+        assert_instance_of CassandraThrift::IndexExpression, ie
+        assert_equal 'foo', ie.column_name
+        assert_equal 'x', ie.value
+        assert_equal CassandraThrift::IndexOperator::LT, ie.op
+      end
+      # alias
+      ["LT", "lt", "<"].each do |op|
+        ie = @twitter.create_idx_expr('foo', 'x', op)
+        assert_instance_of CassandraThrift::IndexExpression, ie
+        assert_equal 'foo', ie.column_name
+        assert_equal 'x', ie.value
+        assert_equal CassandraThrift::IndexOperator::LT, ie.op
+      end
 
-      # 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)
+      # unknown operator
+      ie = @twitter.create_index_expression('foo', 'x', '~$')
+      assert_equal nil, ie.op
+      # alias
+      ie = @twitter.create_idx_expr('foo', 'x', '~$')
+      assert_equal nil, ie.op
     end
 
     def test_column_family_mutation
@@ -843,7 +1144,7 @@ class CassandraTest < Test::Unit::TestCase
       assert_equal(1, @twitter.get(:UserCounterAggregates, 'bob', 'DAU', 'today'))
       assert_equal(2, @twitter.get(:UserCounterAggregates, 'bob', 'DAU', 'tomorrow'))
     end
-    
+
     def test_reading_rows_with_super_column_counter
       assert_nil @twitter.add(:UserCounterAggregates, 'bob', 1, 'DAU', 'today')
       assert_nil @twitter.add(:UserCounterAggregates, 'bob', 2, 'DAU', 'tomorrow')
@@ -853,8 +1154,8 @@ class CassandraTest < Test::Unit::TestCase
       assert_equal("DAU", result.first[0])
       assert_equal(1, result.first[1]["today"])
       assert_equal(2, result.first[1]["tomorrow"])
-    end  
-    
+    end
+
     def test_composite_column_type_conversion
       columns = {}
       @composites.each_with_index do |c, index|
@@ -893,6 +1194,46 @@ class CassandraTest < Test::Unit::TestCase
 
       assert_equal('value-2', @type_conversions.get(:CompositeColumnConversion, key, columns_in_order.first))
     end
+
+    def test_dynamic_composite_column_type_conversion
+      columns = {}
+      @dynamic_composites.each_with_index do |c, index|
+        columns[c] = "value-#{index}"
+      end
+      @type_conversions.insert(:DynamicComposite, key, columns)
+
+      columns_in_order = [
+        Cassandra::DynamicComposite.new(['IntegerType', [1].pack('N')], ['s', "elephant"]),
+        Cassandra::DynamicComposite.new(['i', [5].pack('N')], ['UTF8Type', "aardvark"]),
+        Cassandra::DynamicComposite.new(['i', [5].pack('N')], ['UTF8Type', "zebra"]),
+        Cassandra::DynamicComposite.new(['IntegerType', [10].pack('N')], ['s', "kangaroo"]),
+      ]
+      assert_equal(columns_in_order, @type_conversions.get(:DynamicComposite, key).keys)
+
+      column_slice = @type_conversions.get(:DynamicComposite, key,
+        :start => Cassandra::DynamicComposite.new(['i', [1].pack('N')]),
+        :finish => Cassandra::DynamicComposite.new(['i', [10].pack('N')]),
+      ).keys
+      assert_equal(columns_in_order[0..-2], column_slice)
+
+      column_slice = @type_conversions.get(:DynamicComposite, key,
+        :start => Cassandra::DynamicComposite.new(['IntegerType', [5].pack('N')]),
+        :finish => Cassandra::DynamicComposite.new(['IntegerType', [5].pack('N')], :slice => :after),
+      ).keys
+      assert_equal(columns_in_order[1..2], column_slice)
+
+      column_slice = @type_conversions.get(:DynamicComposite, key,
+        :start => Cassandra::DynamicComposite.new(['i', [5].pack('N')], :slice => :after).to_s,
+      ).keys
+      assert_equal([columns_in_order[-1]], column_slice)
+
+      column_slice = @type_conversions.get(:DynamicComposite, key,
+        :finish => Cassandra::DynamicComposite.new(['i', [10].pack('N')], :slice => :before).to_s,
+      ).keys
+      assert_equal(columns_in_order[0..-2], column_slice)
+
+      assert_equal('value-2', @type_conversions.get(:DynamicComposite, key, columns_in_order.first))
+    end
   end
 
   def test_column_timestamps