cassandra 0.9.1 → 0.10.0

data/lib/cassandra/0.8/keyspace.rb

@@ -0,0 +1,3 @@
+class Cassandra
+  class Keyspace < CassandraThrift::KsDef ; end
+end

data/lib/cassandra/0.8/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, 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
+
+    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))
+
+        keys.inject({}){|hash, key| hash[key] = column_hash[key][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, finish, count, consistency)
+      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+      predicate = CassandraThrift::SlicePredicate.new(:slice_range => CassandraThrift::SliceRange.new(:start => '', :finish => ''))
+      range = CassandraThrift::KeyRange.new(:start_key => start, :end_key => finish, :count => count)
+      client.get_range_slices(column_parent, predicate, range, 1)
+    end
+
+    def _get_range_keys(column_family, start, finish, count, consistency)
+      _get_range(column_family, start, finish, count, consistency).collect{|i| i.key }
+    end
+
+    # TODO: Supercolumn support
+    def _get_indexed_slices(column_family, idx_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, idx_clause, predicate, consistency)
+    end
+
+    def each_key(column_family)
+      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family.to_s)
+      predicate = CassandraThrift::SlicePredicate.new(:column_names => [])
+      range = CassandraThrift::KeyRange.new(:start_key => '', :end_key => '')
+      client.get_range_slices(column_parent, predicate, range, 1).each{|i| yield i.key }
+    end
+  end
+end

data/lib/cassandra/cassandra.rb

@@ -146,9 +146,9 @@ class Cassandra
       mutation_map = 
         {
           key => {
-            column_family => [ _delete_mutation(column_family , is_super(column_family)? column : nil , sub_column , options[:timestamp]|| Time.stamp) ]
+            column_family => [ _delete_mutation(column_family, column, sub_column, options[:timestamp]|| Time.stamp) ]
           }
-        }  
+        }
       @batch << [mutation_map, options[:consistency]]
     else 
       # Let's continue using the 'remove' thrift method...not sure about the implications/performance of using the mutate instead
@@ -276,7 +276,7 @@ class Cassandra
   # Roll up queued mutations, to improve atomicity (and performance).
   def compact_mutations!
     used_clevels = {} # hash that lists the consistency levels seen in the batch array. key is the clevel, value is true
-    by_key = {}
+    by_key = Hash.new{|h,k | h[k] = {}}
     # @batch is an array of mutation_ops.
     # A mutation op is a 2-item array containing [mutationmap, consistency_number]
     # a mutation map is a hash, by key (string) that has a hash by CF name, containing a list of column_mutations)
@@ -291,18 +291,13 @@ class Cassandra
       #      }, # [0]
       #  consistency # [1] 
       #]
-      # For a remove:
-      # [  :remove,  # [0]
-      #    [key, CassThrift:ColPath, timestamp, consistency ]  # [1]
-      # ]
       mmap = mutation_op[0] # :remove OR a hash like {"key"=> {"CF"=>[mutationclass1,...] } }
-      used_clevels[mutation_op[1]]=true #save the clevel required for this operation
+      used_clevels[mutation_op[1]] = true #save the clevel required for this operation
 
       mmap.keys.each do |k|
-        by_key[k] = {} unless by_key.has_key? k #make sure the key exists
         mmap[k].keys.each do |cf| # For each CF in that key
-          by_key[k][cf] = [] unless by_key[k][cf] != nil
-          by_key[k][cf].concat mmap[k][cf] # Append the list of mutations for that key and CF
+          by_key[k][cf] ||= []
+          by_key[k][cf].concat(mmap[k][cf]) # Append the list of mutations for that key and CF
         end
       end
     end

data/lib/cassandra/helpers.rb

@@ -17,6 +17,7 @@ class Cassandra
 
       # Ranges
       column, sub_column = args[0], args[1]
+      raise ArgumentError, "Invalid arguments: subcolumns specified for a non-supercolumn family" if sub_column && !is_super(column_family)      
       klass, sub_klass = column_name_class(column_family), sub_column_name_class(column_family)
       range_class = column ? sub_klass : klass
 

data/lib/cassandra/mock.rb

@@ -1,5 +1,3 @@
-require 'nokogiri'
-
 class SimpleUUID::UUID
   def >=(other)
     (self <=> other) >= 0
@@ -15,11 +13,13 @@ class Cassandra
     include ::Cassandra::Helpers
     include ::Cassandra::Columns
 
-    def initialize(keyspace, storage_xml)
+    def initialize(keyspace, schema)
+      @is_super = {}
       @keyspace = keyspace
       @column_name_class = {}
       @sub_column_name_class = {}
-      @storage_xml = storage_xml
+      @indexes = {}
+      @schema = schema[keyspace]
       clear_keyspace!
     end
 
@@ -39,7 +39,7 @@ class Cassandra
         @batch << [:insert, column_family, key, hash_or_array, options]
       else
         raise ArgumentError if key.nil?
-        if column_family_type(column_family) == 'Standard'
+        if !is_super(column_family)
           insert_standard(column_family, key, hash_or_array)
         else
           insert_super(column_family, key, hash_or_array)
@@ -77,7 +77,7 @@ class Cassandra
     def get(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)
-      if column_family_type(column_family) == 'Standard'
+      if !is_super(column_family)
         get_standard(column_family, key, column, options)
       else
         get_super(column_family, key, column, sub_column, options)
@@ -85,7 +85,9 @@ class Cassandra
     end
 
     def get_standard(column_family, key, column, options)
-      row = cf(column_family)[key] || OrderedHash.new
+      columns = cf(column_family)[key] || OrderedHash.new
+      row = columns_to_hash(column_family, columns)
+
       if column
         row[column]
       else
@@ -95,26 +97,24 @@ class Cassandra
     end
 
     def get_super(column_family, key, column, sub_column, options)
+      columns = cf(column_family)[key] || OrderedHash.new
+      row = columns_to_hash(column_family, columns)
+
       if column
         if sub_column
-          if cf(column_family)[key] &&
-             cf(column_family)[key][column] &&
-             cf(column_family)[key][column][sub_column]
-            cf(column_family)[key][column][sub_column]
+          if row[column] &&
+            row[column][sub_column]
+            row[column][sub_column]
           else
             nil
           end
         else
-          row = cf(column_family)[key] && cf(column_family)[key][column] ?
-            cf(column_family)[key][column] :
-            OrderedHash.new
+          row = row[column] || OrderedHash.new
           row = apply_range(row, column_family, options[:start], options[:finish], false)
           apply_count(row, options[:count], options[:reversed])
         end
-      elsif cf(column_family)[key]
-        cf(column_family)[key]
       else
-        OrderedHash.new
+        row
       end
     end
 
@@ -137,9 +137,9 @@ class Cassandra
       else
         if column
           if sub_column
-            cf(column_family)[key][column].delete(sub_column)
+            cf(column_family)[key][column].delete(sub_column.to_s)
           else
-            cf(column_family)[key].delete(column)
+            cf(column_family)[key].delete(column.to_s)
           end
         else
           cf(column_family).delete(key)
@@ -151,7 +151,6 @@ class Cassandra
       column_family, columns, sub_columns, options = extract_and_validate_params_for_real(column_family, key, columns_and_options, READ_DEFAULTS)
       d = get(column_family, key)
 
-
       if sub_columns
         sub_columns.collect do |sub_column|
           d[columns][sub_column]
@@ -197,16 +196,74 @@ class Cassandra
       count
     end
 
-    def schema(load=true)
-      if !load && !@schema
-        []
+    def create_index(ks_name, cf_name, c_name, v_class)
+      if @indexes[ks_name] &&
+        @indexes[ks_name][cf_name] &&
+        @indexes[ks_name][cf_name][c_name] 
+        nil
+
+      else
+        @indexes[ks_name] ||= {}
+        @indexes[ks_name][cf_name] ||= {}
+        @indexes[ks_name][cf_name][c_name] = true
+      end
+    end
+
+    def drop_index(ks_name, cf_name, c_name)
+      if @indexes[ks_name] &&
+        @indexes[ks_name][cf_name] &&
+        @indexes[ks_name][cf_name][c_name] 
+
+        @indexes[ks_name][cf_name].delete(c_name)
       else
-        @schema ||= schema_for_keyspace(@keyspace)
+        nil
       end
     end
 
+    def create_idx_expr(c_name, value, op)
+      {:column_name => c_name, :value => value, :comparison => op}
+    end
+
+    def create_idx_clause(idx_expressions, start = "")
+      {:start => start, :index_expressions => idx_expressions}
+    end
+
+    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)
+
+      ret = {}
+      cf(column_family).each do |key, row|
+        next if idx_clause[:start] != '' && key < idx_clause[:start]
+
+        matches = []
+        idx_clause[:index_expressions].each do |expr|
+          next if row[expr[:column_name]].nil?
+          next unless row[expr[:column_name]].send(expr[:comparison].to_sym, expr[:value])
+
+          matches << expr
+        end
+
+        ret[key] = row if matches.length == idx_clause[:index_expressions].length
+      end
+
+      ret
+    end
+
+    def schema(load=true)
+      @schema
+    end
+
+    def column_family_property(column_family, key)
+      schema[column_family.to_s][key]
+    end
+
     private
 
+    def schema_for_keyspace(keyspace)
+      @schema
+    end
+
     def _get_range(column_family, start, finish, count)
       ret = OrderedHash.new
       start  = to_compare_with_type(start,  column_family)
@@ -220,30 +277,6 @@ class Cassandra
       ret
     end
 
-    def schema_for_keyspace(keyspace)
-      doc = read_storage_xml
-      ret = {}
-      doc.css("Keyspaces Keyspace[@Name='#{keyspace}']").css('ColumnFamily').each do |cf|
-        ret[cf['Name']] = {}
-        if cf['CompareSubcolumnsWith']
-          ret[cf['Name']]['CompareSubcolumnsWith'] = 'org.apache.cassandra.db.marshal.' + cf['CompareSubcolumnsWith']
-        end
-        if cf['CompareWith']
-          ret[cf['Name']]['CompareWith'] = 'org.apache.cassandra.db.marshal.' + cf['CompareWith']
-        end
-        if cf['ColumnType'] == 'Super'
-          ret[cf['Name']]['Type'] = 'Super'
-        else
-          ret[cf['Name']]['Type'] = 'Standard'
-        end
-      end
-      ret
-    end
-
-    def read_storage_xml
-      @doc ||= Nokogiri::XML(open(@storage_xml))
-    end
-
     def extract_and_validate_params_for_real(column_family, keys, args, options)
       column_family, columns, sub_column, options = extract_and_validate_params(column_family, keys, args, options)
       options[:start] = nil if options[:start] == ''
@@ -264,25 +297,12 @@ class Cassandra
     def to_compare_with_type(column_name, column_family, standard=true)
       return column_name if column_name.nil?
       klass = if standard
-        schema[column_family.to_s]["CompareWith"]
+        column_name_class(column_family)
       else
-        schema[column_family.to_s]["CompareSubcolumnsWith"]
+        sub_column_name_class(column_family)
       end
 
-      case klass
-      when "org.apache.cassandra.db.marshal.UTF8Type", "org.apache.cassandra.db.marshal.BytesType"
-        column_name
-      when "org.apache.cassandra.db.marshal.TimeUUIDType"
-        SimpleUUID::UUID.new(column_name)
-      when "org.apache.cassandra.db.marshal.LongType"
-        Long.new(column_name)
-      else
-        raise "Unknown column family type: #{klass.inspect}"
-      end
-    end
-
-    def column_family_type(column_family)
-      schema[column_family.to_s]['Type']
+      klass.new(column_name)
     end
 
     def cf(column_family)
@@ -293,9 +313,32 @@ class Cassandra
       if new_stuff.is_a?(Array)
         new_stuff = new_stuff.inject({}){|h,k| h[k] = nil; h }
       end
+
+      new_stuff = new_stuff.to_a.inject({}){|h,k| h[k[0].to_s] = k[1]; h }
+
       OrderedHash[old_stuff.merge(new_stuff).sort{|a,b| a[0] <=> b[0]}]
     end
 
+    def columns_to_hash(column_family, columns)
+      column_class, sub_column_class = column_name_class(column_family), sub_column_name_class(column_family)
+      output = OrderedHash.new
+
+      columns.each do |column_name, value|
+        column = column_class.new(column_name)
+
+        if [Hash, OrderedHash].include?(value.class)
+          output[column] ||= OrderedHash.new
+          value.each do |sub_column, sub_column_value|
+            output[column][sub_column_class.new(sub_column)] = sub_column_value
+          end
+        else
+          output[column_class.new(column_name)] = value
+        end
+      end
+
+      output
+    end
+
     def apply_count(row, count, reversed=false)
       if count
         keys = row.keys.sort