cassandra 0.4 → 0.5

data/lib/cassandra/{helper.rb → columns.rb}

@@ -1,8 +1,7 @@
-class Cassandra
 
+class Cassandra
   # A bunch of crap, mostly related to introspecting on column types
-  module Helper
-  
+  module Columns #:nodoc:
     private
     
     def is_super(column_family)
@@ -19,12 +18,13 @@ class Cassandra
     
     def column_name_class_for_key(column_family, comparator_key)
       property = column_family_property(column_family, comparator_key)
-      property =~ /.*\.(.*?)Type/
-      self.class.const_get($1) # Long, UUID
-    rescue NameError      
-      String # UTF8, Ascii, Bytes, anything else
-    rescue TypeError
-      nil # Called sub_column_name_class on a standard column family
+      property =~ /.*\.(.*?)$/
+      case $1
+      when "LongType" then Long
+      when "LexicalUUIDType", "TimeUUIDType" then UUID
+      else 
+        String # UTF8, Ascii, Bytes, anything else
+      end
     end
 
     def column_family_property(column_family, key)
@@ -53,11 +53,12 @@ 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|
-        hash[column_name_class.new(c.name)] = if c.is_a?(CassandraThrift::SuperColumn)
-          # Pop the class stack, and recurse
-          columns_to_hash_for_classes(c.columns, sub_column_name_class)
-        else
-          load(c.value)
+        c = c.super_column || c.column if c.is_a?(CassandraThrift::ColumnOrSuperColumn)
+        hash[column_name_class.new(c.name)] = case c
+          when CassandraThrift::SuperColumn            
+            columns_to_hash_for_classes(c.columns, sub_column_name_class) # Pop the class stack, and recurse
+          when CassandraThrift::Column
+            c.value
         end
       end
       hash    
@@ -70,7 +71,7 @@ class Cassandra
     
     def hash_to_columns_without_assertion(column_family, hash, timestamp)
       hash.map do |column, value|
-        CassandraThrift::Column.new(:name => column.to_s, :value => dump(value), :timestamp => timestamp)
+        CassandraThrift::Column.new(:name => column.to_s, :value => value, :timestamp => timestamp)
       end    
     end    
     

data/lib/cassandra/comparable.rb

@@ -2,7 +2,7 @@
 class Cassandra
   # Abstract base class for comparable numeric column name types
   class Comparable
-    class TypeError < ::TypeError
+    class TypeError < ::TypeError #:nodoc:
     end
   
     def <=>(other)

data/lib/cassandra/constants.rb

@@ -1,6 +1,10 @@
 
 class Cassandra
+  # A helper module you can include in your own class. Makes it easier 
+  # to work with Cassandra subclasses.
   module Constants
+    include Cassandra::Consistency
+        
     UUID = Cassandra::UUID
     Long = Cassandra::Long
     OrderedHash = Cassandra::OrderedHash

data/lib/cassandra/long.rb

@@ -2,38 +2,40 @@
 class Cassandra
   # A temporally-ordered Long class for use in Cassandra column names
   class Long < Comparable
-    ENTROPY = 2**12
-    MAX = 2**64
-    
+  
     def initialize(bytes = nil)      
       case bytes
       when String
         raise TypeError, "8 bytes required" if bytes.size != 8
         @bytes = bytes
       when Integer
-        raise TypeError, "Integer must be between 0 and 2**64" if bytes < 0 or bytes > MAX
-        @bytes = [bytes].pack("Q")
+        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
         # Time.stamp is 52 bytes, so we have 12 bytes of entropy left over
-        @bytes = [Time.stamp * ENTROPY + rand(ENTROPY)].pack("Q")
+        int = (Time.stamp << 12) + rand(2**12)
+        @bytes = [int >> 32, int % 2**32].pack("NN")
       else
         raise TypeError, "Can't convert from #{bytes.class}"
       end
     end
 
     def to_i
-      @to_i ||= @bytes.unpack("Q")[0]
+      @to_i ||= begin
+        ints = @bytes.unpack("NN")
+        (ints[0] << 32) + 
+        ints[1]
+      end
     end    
     
     def inspect
-      ints = @bytes.unpack("Q")
       "<Cassandra::Long##{object_id} time: #{
-          Time.at((ints[0] / ENTROPY) / 1_000_000).inspect
-        }, usecs: #{
-          (ints[0] / ENTROPY) % 1_000_000
-        }, jitter: #{
-          ints[0] % ENTROPY
-        }>"
+        Time.at((to_i >> 12) / 1_000_000).inspect
+      }, usecs: #{
+        (to_i >> 12) % 1_000_000
+      }, jitter: #{
+        to_i % 2**12
+      }>"
     end      
   end  
 end

data/lib/cassandra/ordered_hash.rb

@@ -25,7 +25,7 @@ class Cassandra
     #  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
     #  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   
-    class OrderedHash < Hash
+    class OrderedHash < Hash #:nodoc: all
       require 'enumerator'    
     
       def self.[](*array)

data/lib/cassandra/protocol.rb

@@ -0,0 +1,86 @@
+
+class Cassandra
+  # Inner methods for actually doing the Thrift calls
+  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)
+    end
+
+    def _count_columns(column_family, key, super_column, consistency)
+      @client.get_count(@keyspace, key,
+        CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => super_column),
+        consistency
+      )
+    end
+
+    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(@keyspace, 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(@keyspace, 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(@keyspace, key,
+          CassandraThrift::ColumnParent.new(:column_family => column_family),
+          CassandraThrift::SlicePredicate.new(:column_names => columns),
+          consistency))
+      end
+      sub_columns || columns.map { |name| result[name] }
+    end
+
+    def _get(column_family, key, 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
+        column_path = CassandraThrift::ColumnPath.new(:column_family => column_family, :super_column => column, :column => sub_column)
+        @client.get(@keyspace, key, column_path, consistency).column.value
+      elsif !is_super(column_family) and column
+        column_path = CassandraThrift::ColumnPath.new(:column_family => column_family, :column => column)
+        @client.get(@keyspace, key, column_path, consistency).column.value
+
+      # Slices
+      else
+        # FIXME Comparable types in range are not enforced
+        predicate = CassandraThrift::SlicePredicate.new(:slice_range => 
+          CassandraThrift::SliceRange.new(
+            :is_ascending => !reversed, 
+            :count => count, 
+            :start => start.to_s, 
+            :finish => finish.to_s))
+        
+        if is_super(column_family) and column
+          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => column)
+          sub_columns_to_hash(column_family, @client.get_slice(@keyspace, key, column_parent, predicate, consistency))
+        else
+          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+          columns_to_hash(column_family, @client.get_slice(@keyspace, key, column_parent, predicate, consistency))
+        end
+      end
+    end
+
+    def _get_range(column_family, start, finish, count, consistency)
+      # FIXME Consistency is ignored
+      @client.get_key_range(@keyspace, column_family, start.to_s, finish.to_s, count)
+    end
+  end
+end

data/lib/cassandra/safe_client.rb

@@ -1,5 +1,5 @@
 
-module CassandraThrift
+module CassandraThrift #:nodoc: all
   module Cassandra
     class SafeClient  
       def initialize(client, transport)

data/lib/cassandra/time.rb

@@ -1,9 +1,11 @@
 
-class << Time
-  def now_in_useconds
-    time = Time.now
-    time.to_i * 1_000_000 + time.usec
-  end  
-  alias :stamp :now_in_useconds
+class Time
+  def self.stamp
+    Time.now.stamp
+  end
+  
+  def stamp
+    to_i * 1_000_000 + usec
+  end
 end
         

data/lib/cassandra/uuid.rb

@@ -1,44 +1,109 @@
 
 class Cassandra
-  # A temporally-ordered UUID class for use in Cassandra column names
+
+  # UUID format version 1, as specified in RFC 4122, with jitter in place of the mac address and sequence counter.
   class UUID < Comparable
-    UINT = 2**32
-    LONG = 2**64
-    MAX = 2**128
+
+    class InvalidVersion < StandardError #:nodoc:
+    end
+
+    GREGORIAN_EPOCH_OFFSET = 0x01B2_1DD2_1381_4000 # Oct 15, 1582
     
-    def initialize(bytes = nil)      
+    VARIANT = 0b1000_0000_0000_0000
+
+    def initialize(bytes = nil)
       case bytes
       when String
-        raise TypeError, "16 bytes required" if bytes.size != 16
-        @bytes = bytes
+        case bytes.size
+        when 16
+          @bytes = bytes          
+        when 36
+          elements = bytes.split("-")
+          raise TypeError, "Malformed UUID representation" if elements.size != 5
+          @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 > MAX
-        @bytes = [bytes / LONG, bytes % LONG].pack("QQ")
-      when NilClass
-        @bytes = [Time.stamp, Process.pid, rand(UINT)].pack("QII")
+        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 & 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         
+          rand(2**13) | VARIANT,
+          rand(2**16),
+          rand(2**32)
+        ].pack("NnnnnN")
+        
       else
         raise TypeError, "Can't convert from #{bytes.class}"
       end
     end
-    
+
     def to_i
-      @to_i ||= begin
-        ints = @bytes.unpack("QQ")
-        ints[0] * 2**64 + ints[1]        
-      end
+      ints = @bytes.unpack("NNNN")
+      (ints[0] << 96) + 
+      (ints[1] << 64) + 
+      (ints[2] << 32) + 
+      ints[3]
+    end
+
+    def version
+      time_high = @bytes.unpack("NnnQ")[2]
+      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
+
+    def to_guid
+      elements = @bytes.unpack("NnnCCa6")
+      node = elements[-1].unpack('C*')
+      elements[-1] = '%02x%02x%02x%02x%02x%02x' % node
+      "%08x-%04x-%04x-%02x%02x-%s" % elements
     end
     
-    def inspect
-      ints = @bytes.unpack("QII")
+    def seconds
+      total_usecs / 1_000_000
+    end
+    
+    def usecs
+      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(ints[0] / 1_000_000).inspect
-        }, usecs: #{
-          ints[0] % 1_000_000
-        }, pid: #{
-          ints[1]
-        }, jitter: #{
-          ints[2]
-        }>"
-    end      
-  end  
+        Time.at(seconds).inspect
+      }, usecs: #{
+        usecs
+      } jitter: #{
+        @bytes.unpack('QQ')[1]
+      }" + (long ? ", version: #{version}, variant: #{variant}, guid: #{to_guid}>" :  ">")
+    end    
+    
+    private
+    
+    def total_usecs
+      elements = @bytes.unpack("NnnQ")
+      (elements[0] + (elements[1] << 32) + ((elements[2] & 0x0FFF) << 48) - GREGORIAN_EPOCH_OFFSET) / 10      
+    end
+  end
 end

data/test/{cassandra_client_test.rb → cassandra_test.rb}

@@ -1,8 +1,4 @@
-
-require 'test/unit'
-require "#{File.expand_path(File.dirname(__FILE__))}/../lib/cassandra"
-
-begin; require 'ruby-debug'; rescue LoadError; end
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
 class CassandraTest < Test::Unit::TestCase
   include Cassandra::Constants
@@ -12,6 +8,7 @@ class CassandraTest < Test::Unit::TestCase
     @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))) }    
   end
 
   def test_inspect
@@ -38,14 +35,14 @@ class CassandraTest < Test::Unit::TestCase
 
   def test_get_key_name_sorted_preserving_order
     # In-order hash is preserved
-    hash = OrderedHash['a', nil, 'b', nil, 'c', nil, 'd', nil,]
+    hash = OrderedHash['a', '', 'b', '', 'c', '', 'd', '',]
     @twitter.insert(:Users, key, hash)
     assert_equal(hash.keys, @twitter.get(:Users, key).keys)
 
     @twitter.remove(:Users, key)
 
     # Out-of-order hash is returned sorted
-    hash = OrderedHash['b', nil, 'c', nil, 'd', nil, 'a', nil]
+    hash = OrderedHash['b', '', 'c', '', 'd', '', 'a', '']
     @twitter.insert(:Users, key, hash)
     assert_equal(hash.keys.sort, @twitter.get(:Users, key).keys)
     assert_not_equal(hash.keys, @twitter.get(:Users, key).keys)
@@ -57,6 +54,12 @@ class CassandraTest < Test::Unit::TestCase
     assert_equal({}, @twitter.get(:Statuses, 'bogus'))
   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  
+
   def test_get_value
     @twitter.insert(:Statuses, key, {'body' => 'v'})
     assert_equal 'v', @twitter.get(:Statuses, key, 'body')
@@ -65,15 +68,9 @@ class CassandraTest < Test::Unit::TestCase
     assert @twitter.exists?(:Statuses, key, 'body')
     assert_nil @twitter.exists?(:Statuses, 'bogus', 'body')
   end
-
-  def test_get_value_nil
-    @twitter.insert(:Statuses, key, {'body' => nil})
-    assert_nil @twitter.get(:Statuses, key, 'body')
-    assert @twitter.exists?(:Statuses, key, 'body')
-  end
-
+  
   def test_get_super_key
-    columns = {'user_timelines' => {Long.new => '4', Long.new => '5'}}
+    columns = {'user_timelines' => {@uuids[4] => '4', @uuids[5] => '5'}}
     @twitter.insert(:StatusRelationships, key, columns)
     assert_equal(columns, @twitter.get(:StatusRelationships, key))
     assert_equal({}, @twitter.get(:StatusRelationships, 'bogus'))
@@ -81,57 +78,60 @@ class CassandraTest < Test::Unit::TestCase
 
   def test_get_several_super_keys
     columns = {
-      'user_timelines' => {Long.new => 'v1'},
-      'mentions_timelines' => {Long.new => 'v2'}}
+      'user_timelines' => {@uuids[1]  => 'v1'},
+      'mentions_timelines' => {@uuids[2]  => 'v2'}}
     @twitter.insert(:StatusRelationships, key, columns)
 
     assert_equal(columns, @twitter.get(:StatusRelationships, key))
     assert_equal({}, @twitter.get(:StatusRelationships, 'bogus'))
   end
 
-  def test_get_super_sub_keys_with_limit
-    columns = {Long.new => 'v1'}
-    @twitter.insert(:StatusRelationships, key, {'user_timelines' => columns})
-    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {Long.new => 'v2'}})
-    assert_equal(columns, @twitter.get(:StatusRelationships, key, "user_timelines", nil, 1))
-  end
-
-  def test_get_super_sub_keys_with_ranges
-    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {Long.new => 'v1'}})
-    first_column = {Long.new => 'v2'}
-    @twitter.insert(:StatusRelationships, key, {'user_timelines' => first_column})
-    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {Long.new => 'v3', Long.new => 'v4'}})    
-    last_column = {Long.new => 'v5'}
-    @twitter.insert(:StatusRelationships, key, {'user_timelines' => last_column})
-    
+  def test_get_super_sub_keys_with_count
+    @twitter.insert(:StatusRelationships, key, 
+      {'user_timelines' => {@uuids[1]  => 'v1', @uuids[2]  => 'v2', @uuids[3]  => 'v3'}})
+    assert_equal({@uuids[1]  => 'v1'}, 
+      @twitter.get(:StatusRelationships, key, "user_timelines", :count => 1))
+    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, 
+      {'user_timelines' => {
+        @uuids[1] => 'v1', 
+        @uuids[2] => 'v2', 
+        @uuids[3] => 'v3',
+        @uuids[4] => 'v4', 
+        @uuids[5] => 'v5'}})
+
     keys = @twitter.get(:StatusRelationships, key, "user_timelines").keys
-    assert_equal keys.sort, keys
-    
-    assert_equal(first_column, @twitter.get(:StatusRelationships, key, "user_timelines", nil, 1, first_column.keys.first..''))
-    assert_equal(3, @twitter.get(:StatusRelationships, key, "user_timelines", nil, 100, last_column.keys.first..first_column.keys.first).size)
+    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
   end
 
   def test_get_super_sub_key
-    columns = {Long.new => 'v', Long.new => 'v'}
+    columns = {@uuids[1] => 'v1', @uuids[2] => 'v2'}
     @twitter.insert(:StatusRelationships, key, {'user_timelines' => columns})
     assert_equal(columns, @twitter.get(:StatusRelationships, key, 'user_timelines'))
     assert_equal({}, @twitter.get(:StatusRelationships, 'bogus', 'user_timelines'))
   end
 
   def test_get_super_value
-    columns = {Long.new => 'v'}
+    columns = {@uuids[1] => 'v1'}
     @twitter.insert(:StatusRelationships, key, {'user_timelines' => columns})
-    assert_equal('v', @twitter.get(:StatusRelationships, key, 'user_timelines', columns.keys.first))
+    assert_equal('v1', @twitter.get(:StatusRelationships, key, 'user_timelines', columns.keys.first))
     assert_nil @twitter.get(:StatusRelationships, 'bogus', 'user_timelines', columns.keys.first)
   end
 
-  def test_get_key_range
+  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_key_range(:Statuses, '3'..'5'))
+    assert_equal(['3', '4', '5'], @twitter.get_range(:Statuses, :start => '3', :finish => '5'))
   end
 
   def test_multi_get
@@ -151,7 +151,7 @@ class CassandraTest < Test::Unit::TestCase
 
     @twitter.remove(:Statuses, key)
     assert_equal({}, @twitter.get(:Statuses, key))
-    assert_equal 0, @twitter.count(:Statuses)
+    assert_equal 0, @twitter.count_range(:Statuses)
   end
 
   def test_remove_value
@@ -161,19 +161,19 @@ class CassandraTest < Test::Unit::TestCase
   end
 
   def test_remove_super_key
-    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {Long.new => 'v'}})
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {@uuids[1] => 'v1'}})
     @twitter.remove(:StatusRelationships, key)
     assert_equal({}, @twitter.get(:StatusRelationships, key))
   end
 
   def test_remove_super_sub_key
-    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {Long.new => 'v'}})
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {@uuids[1] => 'v1'}})
     @twitter.remove(:StatusRelationships, key, 'user_timelines')
     assert_equal({}, @twitter.get(:StatusRelationships, key, 'user_timelines'))
   end
 
   def test_remove_super_value
-    columns = {Long.new => 'v'}
+    columns = {@uuids[1] => 'v1'}
     @twitter.insert(:StatusRelationships, key, {'user_timelines' => columns})
     @twitter.remove(:StatusRelationships, key, 'user_timelines', columns.keys.first)
     assert_nil @twitter.get(:StatusRelationships, key, 'user_timelines', columns.keys.first)
@@ -184,7 +184,7 @@ class CassandraTest < Test::Unit::TestCase
     @twitter.insert(:Statuses, key + "2", {'body' => '2'})
     @twitter.insert(:Statuses, key + "3", {'body' => '3'})
     @twitter.clear_column_family!(:Statuses)
-    assert_equal 0, @twitter.count(:Statuses)
+    assert_equal 0, @twitter.count_range(:Statuses)
   end
 
   def test_insert_key
@@ -193,7 +193,7 @@ class CassandraTest < Test::Unit::TestCase
   end
 
   def test_insert_super_key
-    columns = {Long.new => 'v', Long.new => 'v'}
+    columns = {@uuids[1] => 'v1', @uuids[2] => 'v2'}
     @twitter.insert(:StatusRelationships, key, {'user_timelines' => columns})
     assert_equal(columns, @twitter.get(:StatusRelationships, key, 'user_timelines'))
   end
@@ -204,7 +204,7 @@ class CassandraTest < Test::Unit::TestCase
   end
 
   def test_get_column_values_super
-    user_columns, mentions_columns = {Long.new => 'v1'}, {Long.new => 'v2'}
+    user_columns, mentions_columns = {@uuids[1] => 'v1'}, {@uuids[2] => 'v2'}
     @twitter.insert(:StatusRelationships, key,
       {'user_timelines' => user_columns, 'mentions_timelines' => mentions_columns})
     assert_equal [user_columns, mentions_columns],
@@ -225,8 +225,8 @@ class CassandraTest < Test::Unit::TestCase
   # Not supported
   #  def test_get_columns_super_sub
   #    @twitter.insert(:StatusRelationships, key, {
-  #      'user_timelines' => {Long.new => 'v1'},
-  #      'mentions_timelines' => {Long.new => 'v2'}})
+  #      'user_timelines' => {@uuids[1] => 'v1'},
+  #      'mentions_timelines' => {@uuids[2] => 'v2'}})
   #    assert_equal ['v1', 'v2'],
   #      @twitter.get_columns(:StatusRelationships, key, 'user_timelines', ['1', key])
   #  end
@@ -235,7 +235,7 @@ class CassandraTest < Test::Unit::TestCase
     @twitter.insert(:Statuses, key + "1", {'body' => '1'})
     @twitter.insert(:Statuses, key + "2", {'body' => '2'})
     @twitter.insert(:Statuses, key + "3", {'body' => '3'})
-    assert_equal 3, @twitter.count(:Statuses)
+    assert_equal 3, @twitter.count_range(:Statuses)
   end
 
   def test_count_columns
@@ -245,13 +245,13 @@ class CassandraTest < Test::Unit::TestCase
 
   def test_count_super_columns
     @twitter.insert(:StatusRelationships, key, {
-      'user_timelines' => {Long.new => 'v1'},
-      'mentions_timelines' => {Long.new => 'v2'}})
+      'user_timelines' => {@uuids[1] => 'v1'},
+      'mentions_timelines' => {@uuids[2] => 'v2'}})
     assert_equal 2, @twitter.count_columns(:StatusRelationships, key)
   end
 
   def test_count_super_sub_columns
-    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {Long.new => 'v1', Long.new => 'v2'}})
+    @twitter.insert(:StatusRelationships, key, {'user_timelines' => {@uuids[1] => 'v1', @uuids[2] => 'v2'}})
     assert_equal 2, @twitter.count_columns(:StatusRelationships, key, 'user_timelines')
   end