cassilds 0.9.2 → 0.12.1

data/lib/cassandra/protocol.rb

@@ -0,0 +1,120 @@
+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
+
+    def _count_columns(column_family, key, super_column, start, stop, count, 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  => start  || '',
+                                              :finish => stop   || '',
+                                              :count  => count  || 100
+                                            )),
+        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, start, finish, count, 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, reversed=false)
+      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,
+                        :reversed => reversed))
+                  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/lib/cassandra.rb

@@ -1,9 +1,7 @@
 require 'rubygems'
-gem 'thrift', '>= 0.5.0'
-require 'thrift'
-gem 'thrift_client', '>= 0.6.0'
+gem 'thrift_client', '~> 0.7.0'
 require 'thrift_client'
-gem 'simple_uuid' , '>= 0.1.0'
+gem 'simple_uuid' , '~> 0.2.0'
 require 'simple_uuid'
 
 require 'json' unless defined?(JSON)
@@ -12,7 +10,7 @@ here = File.expand_path(File.dirname(__FILE__))
 
 class Cassandra ; end
 unless Cassandra.respond_to?(:VERSION)
-  require "#{here}/cassandra/0.7"
+  require "#{here}/cassandra/0.8"
 end
 
 $LOAD_PATH << "#{here}/../vendor/#{Cassandra.VERSION}/gen-rb"
@@ -27,13 +25,14 @@ require 'cassandra/comparable'
 require 'cassandra/long'
 require 'cassandra/ordered_hash'
 require 'cassandra/columns'
+require 'cassandra/protocol'
 require "cassandra/#{Cassandra.VERSION}/columns"
 require "cassandra/#{Cassandra.VERSION}/protocol"
 require "cassandra/cassandra"
 require "cassandra/#{Cassandra.VERSION}/cassandra"
 unless Cassandra.VERSION.eql?("0.6")
-  require "cassandra/#{Cassandra.VERSION}/column_family"
-  require "cassandra/#{Cassandra.VERSION}/keyspace"
+  require "cassandra/column_family"
+  require "cassandra/keyspace"
 end
 require 'cassandra/constants'
 require 'cassandra/debug' if ENV['DEBUG']

data/test/cassandra_mock_test.rb

@@ -1,21 +1,25 @@
 require File.expand_path(File.dirname(__FILE__) + '/test_helper')
-require 'cassandra_test'
+require File.expand_path(File.dirname(__FILE__) + '/cassandra_test')
 require 'cassandra/mock'
+require 'json'
 
 class CassandraMockTest < CassandraTest
   include Cassandra::Constants
 
   def setup
-    storage_xml_path = File.expand_path(File.join(File.dirname(File.dirname(__FILE__)), 'conf', 'storage-conf.xml'))
-    @twitter = Cassandra::Mock.new('Twitter', storage_xml_path)
+    @test_schema = JSON.parse(File.read(File.join(File.expand_path(File.dirname(__FILE__)), '..','conf', CASSANDRA_VERSION, 'schema.json')))
+    @twitter = Cassandra::Mock.new('Twitter', @test_schema)
     @twitter.clear_keyspace!
 
-    @blogs = Cassandra::Mock.new('Multiblog', storage_xml_path)
+    @blogs = Cassandra::Mock.new('Multiblog', @test_schema)
     @blogs.clear_keyspace!
 
-    @blogs_long = Cassandra::Mock.new('MultiblogLong', storage_xml_path)
+    @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
@@ -27,28 +31,7 @@ class CassandraMockTest < CassandraTest
   end
   
   def test_schema_for_keyspace
-    data = {
-      "StatusRelationships"=>{
-          "CompareSubcolumnsWith"=>"org.apache.cassandra.db.marshal.TimeUUIDType", 
-          "CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type",
-          "Type"=>"Super"},
-      "StatusAudits"=>{
-        "CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type",
-        "Type"=>"Standard"}, 
-      "Statuses"=>{
-        "CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type",
-        "Type"=>"Standard"}, 
-      "UserRelationships"=>{
-        "CompareSubcolumnsWith"=>"org.apache.cassandra.db.marshal.TimeUUIDType", 
-        "CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type",
-        "Type"=>"Super"}, 
-      "UserAudits"=>{
-        "CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type", 
-        "Type"=>"Standard"},
-      "Users"=>{"CompareWith"=>"org.apache.cassandra.db.marshal.UTF8Type", "Type"=>"Standard"},
-      "TimelinishThings"=>
-        {"CompareWith"=>"org.apache.cassandra.db.marshal.BytesType", "Type"=>"Standard"}
-    }
+    data = @test_schema['Twitter']
     stuff = @twitter.send(:schema_for_keyspace, 'Twitter')
     data.keys.each do |k|
       assert_equal data[k], stuff[k], k
@@ -58,7 +41,48 @@ 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_get_range_reversed
+    data = 3.times.map { |i| ["body-#{i.to_s}", "v"] }
+    hash = Cassandra::OrderedHash[data]
+    reversed_hash = Cassandra::OrderedHash[data.reverse]
+    
+    @twitter.insert(:Statuses, "all-keys", hash)
+    
+    columns = @twitter.get_range(:Statuses, :reversed => true)["all-keys"]
+    columns.each do |column|
+      assert_equal reversed_hash.shift, column
+    end
+  end
+  
+  def test_get_range_reversed_slice
+    data = 4.times.map { |i| ["body-#{i.to_s}", "v"] }
+    hash = Cassandra::OrderedHash[data]
+    sliced_hash = Cassandra::OrderedHash[data.reverse[1..-1]]
+    
+    @twitter.insert(:Statuses, "all-keys", hash)
+    
+    columns = @twitter.get_range(
+      :Statuses,
+      :start => sliced_hash.keys.first,
+      :reversed => true
+    )["all-keys"]
+    
+    columns.each do |column|
+      assert_equal sliced_hash.shift, column
+    end
+  end
+  
+  def test_get_range_count
+    data = 3.times.map { |i| ["body-#{i.to_s}", "v"] }
+    hash = Cassandra::OrderedHash[data]
+    
+    @twitter.insert(:Statuses, "all-keys", hash)
+    
+    columns = @twitter.get_range(:Statuses, :count => 2)["all-keys"]
+    assert_equal 2, columns.count
   end
 
   def test_inserting_array_for_indices