cassilds 0.9.2 → 0.12.1

data/lib/cassandra/columns.rb

@@ -4,15 +4,15 @@ class Cassandra
   module Columns #:nodoc:
 
     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
 
     private
@@ -29,10 +29,20 @@ 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)
+      ret = OrderedHash.new
+      array.each do |value|
+        next if return_empty_rows == false && value.columns.length == 0
+        ret[value.key] = columns_to_hash(column_family, value.columns)
+      end
+      ret
     end
 
     def multi_column_to_hash!(hash)
@@ -64,16 +74,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/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/long.rb

@@ -39,6 +39,11 @@ class Cassandra
       end
     end
 
+    def to_s
+      @bytes
+    end
+    alias :bytes :to_s
+
     def to_guid
       "%08x-%04x-%04x" % @bytes.unpack("Nnn")
     end    

data/lib/cassandra/mock.rb

@@ -1,5 +1,3 @@
-require 'nokogiri'
-
 class SimpleUUID::UUID
   def >=(other)
     (self <=> other) >= 0
@@ -15,11 +13,15 @@ class Cassandra
     include ::Cassandra::Helpers
     include ::Cassandra::Columns
 
-    def initialize(keyspace, storage_xml)
+    attr_reader :keyspace
+
+    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
 
@@ -34,12 +36,20 @@ 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]
       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 +87,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,41 +95,44 @@ 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
         row = apply_range(row, column_family, options[:start], options[:finish])
-        apply_count(row, options[:count], options[:reversed])
+        row = apply_count(row, options[:count], options[:reversed])
       end
     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])
+          row = apply_count(row, options[:count], options[:reversed])
         end
-      elsif cf(column_family)[key]
-        cf(column_family)[key]
       else
-        OrderedHash.new
+        row
       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)
@@ -133,13 +146,13 @@ class Cassandra
     def remove(column_family, key, *columns_and_options)
       column_family, column, sub_column, options = extract_and_validate_params_for_real(column_family, key, columns_and_options, WRITE_DEFAULTS)
       if @batch
-        @batch << [:remove, column_family, key, column]
+        @batch << [:remove, column_family, key, column, sub_column]
       else
         if column
           if sub_column
-            cf(column_family)[key][column].delete(sub_column)
+            cf(column_family)[key][column].delete(sub_column.to_s) if cf(column_family)[key][column]
           else
-            cf(column_family)[key].delete(column)
+            cf(column_family)[key].delete(column.to_s)  if cf(column_family)[key]
           end
         else
           cf(column_family).delete(key)
@@ -151,7 +164,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]
@@ -163,8 +175,10 @@ class Cassandra
       end
     end
 
-    def count_columns(column_family, key, column=nil)
-      get(column_family, key, column).keys.length
+    def count_columns(column_family, key, *columns_and_options)
+      column_family, columns, sub_columns, options = extract_and_validate_params_for_real(column_family, key, columns_and_options, READ_DEFAULTS)
+
+      get(column_family, key, columns, options).keys.length
     end
 
     def multi_get_columns(column_family, keys, columns)
@@ -181,67 +195,217 @@ class Cassandra
       end
     end
 
-    def get_range(column_family, options = {})
-      column_family, _, _, options = extract_and_validate_params_for_real(column_family, "", [options], READ_DEFAULTS)
-      _get_range(column_family, options[:start], options[:finish], options[:count]).keys
+    def get_range(column_family, options = {}, &blk)
+      column_family, _, _, options = extract_and_validate_params_for_real(column_family, "", [options],
+                                                                          READ_DEFAULTS.merge(:start_key  => nil,
+                                                                                              :finish_key => nil,
+                                                                                              :key_count  => 100,
+                                                                                              :columns    => nil,
+                                                                                              :reversed   => false
+                                                                                             )
+                                                                         )
+      res = _get_range(column_family,
+                 options[:start_key],
+                 options[:finish_key],
+                 options[:key_count],
+                 options[:columns],
+                 options[:start],
+                 options[:finish],
+                 options[:count],
+                 options[:consistency],
+                 options[:reversed], &blk)
+
+      if blk.nil?
+        res
+      else
+        nil
+      end
+    end
+
+    def get_range_keys(column_family, options = {})
+      get_range(column_family,options.merge!(:columns => [])).keys
     end
 
-    def count_range(column_family, options={})
-      count = 0
-      l = []
-      start_key = ''
-      while (l = get_range(column_family, options.merge(:count => 1000, :start => start_key))).size > 0
-        count += l.size
-        start_key = l.last.succ
+    def count_range(column_family, options = {})
+      Hash[get_range(column_family, options).select{|k,v| v.length > 0}].keys.compact.length
+    end
+
+    def each_key(column_family, options = {})
+      each(column_family, options.merge!(:columns => [])) do |key, value|
+        yield key
       end
-      count
     end
 
-    def schema(load=true)
-      if !load && !@schema
-        []
+    def each(column_family, options = {})
+      batch_size    = options.delete(:batch_size) || 100
+      count         = options.delete(:key_count)
+      yielded_count = 0
+
+      options[:start_key] ||= ''
+      last_key  = nil
+
+      while options[:start_key] != last_key && (count.nil? || count > yielded_count)
+        options[:start_key] = last_key
+        res = get_range(column_family, options.merge!(:start_key => last_key, :key_count => batch_size))
+        res.each do |key, columns|
+          next if options[:start_key] == key
+          next if yielded_count == count
+          yield key, columns
+          yielded_count += 1
+          last_key = key
+        end
+      end
+    end
+
+    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
-        @schema ||= schema_for_keyspace(@keyspace)
+        @indexes[ks_name] ||= {}
+        @indexes[ks_name][cf_name] ||= {}
+        @indexes[ks_name][cf_name][c_name] = true
       end
     end
 
-    private
+    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]
 
-    def _get_range(column_family, start, finish, count)
-      ret = OrderedHash.new
-      start  = to_compare_with_type(start,  column_family)
-      finish = to_compare_with_type(finish, column_family)
-      cf(column_family).keys.sort.each do |key|
-        break if ret.keys.size >= count
-        if (start.nil? || key >= start) && (finish.nil? || key <= finish)
-          ret[key] = cf(column_family)[key]
-        end
+        @indexes[ks_name][cf_name].delete(c_name)
+      else
+        nil
       end
-      ret
     end
 
-    def schema_for_keyspace(keyspace)
-      doc = read_storage_xml
+    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_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.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 = {}
-      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'
+      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|
+          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 read_storage_xml
-      @doc ||= Nokogiri::XML(open(@storage_xml))
+    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 column_families
+      cf_defs = {}
+      schema.each do |key, value|
+        cf_def = Cassandra::ColumnFamily.new
+
+        value.each do |property, property_value|
+          cf_def.send(:"#{property}=", property_value)
+        end
+
+        cf_defs[key] = cf_def
+      end
+
+      cf_defs
+    end
+
+    def schema(load=true)
+      @schema
+    end
+
+    def column_family_property(column_family, key)
+      schema[column_family.to_s][key]
+    end
+
+    def add_column_family(cf)
+      @schema[cf.name.to_s] ||= OrderedHash.new
+
+      cf.instance_variables.each do |var|
+        @schema[cf.name.to_s][var.slice(1..-1)] = cf.instance_variable_get(var)
+      end
+    end
+
+    def update_column_family(cf)
+      return false unless @schema.include?(cf.name.to_s)
+
+      cf.instance_variables.each do |var|
+        @schema[cf.name.to_s][var.slice(1..-1)] = cf.instance_variable_get(var)
+      end
+    end
+
+    def drop_column_family(column_family_name)
+      @schema.delete(column_family_name)
+    end
+
+    private
+
+    def schema_for_keyspace(keyspace)
+      @schema
+    end
+
+    def _get_range(column_family, start_key, finish_key, key_count, columns, start, finish, count, consistency, reversed, &blk)
+      ret = OrderedHash.new
+      start  = to_compare_with_type(start,  column_family)
+      finish = to_compare_with_type(finish, column_family)
+      cf(column_family).keys.sort.each do |key|
+        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_to_hash(column_family, cf(column_family)[key].select{|k,v| columns.include?(k)})
+            ret[key] = apply_count(ret[key], count, reversed)
+            blk.call(key,ret[key]) unless blk.nil?
+          else
+            #ret[key] = apply_range(cf(column_family)[key], column_family, start, finish, !is_super(column_family))
+            start, finish = finish, start if reversed
+            ret[key] = apply_range(columns_to_hash(column_family, cf(column_family)[key]), column_family, start, finish)
+            ret[key] = apply_count(ret[key], count, reversed)
+            blk.call(key,ret[key]) unless blk.nil?
+          end
+        end
+      end
+      ret
     end
 
     def extract_and_validate_params_for_real(column_family, keys, args, options)
@@ -264,25 +428,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 +444,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

data/lib/cassandra/ordered_hash.rb

@@ -1,9 +1,5 @@
 # OrderedHash is namespaced to prevent conflicts with other implementations
 class Cassandra
-  # Hash is ordered in Ruby 1.9!
-  if RUBY_VERSION >= '1.9'
-    OrderedHashInt = ::Hash
-  else
     class OrderedHashInt < Hash #:nodoc:
       def initialize(*args, &block)
         super
@@ -126,6 +122,10 @@ class Cassandra
         @keys = other.keys
         self
       end
+      
+      def reverse
+        OrderedHashInt[self.to_a.reverse]
+      end
 
     private
 
@@ -133,11 +133,10 @@ class Cassandra
         @keys.delete_if {|k| !has_key?(k)}
       end
     end
-  end
 
   class OrderedHash < OrderedHashInt #:nodoc:
     def initialize(*args, &block)
-      @timestamps = Hash.new
+      @timestamps = OrderedHashInt.new
       super
     end
 
@@ -156,13 +155,13 @@ class Cassandra
       super
     end
 
-    def delete_if
-      @timestamps.delete_if
+    def delete_if(&block)
+      @timestamps.delete_if(&block)
       super
     end
 
-    def reject!
-      @timestamps.reject!
+    def reject!(&block)
+      @timestamps.reject!(&block)
       super
     end
 
@@ -189,12 +188,5 @@ class Cassandra
     def inspect
       "#<OrderedHash #{super}--TimeStamps: #{@timestamps.inspect}>"
     end
-
-  private
-
-    def sync_keys!
-      @timestamps.delete_if {|k,v| !has_key?(k)}
-      super
-    end
   end
-end
+end