cassandra-mavericks 0.21.1

data/lib/cassandra/column_family.rb

@@ -0,0 +1,3 @@
+class Cassandra
+  class ColumnFamily < CassandraThrift::CfDef ; end
+end

data/lib/cassandra/columns.rb

@@ -0,0 +1,172 @@
+
+class Cassandra
+  # A bunch of crap, mostly related to introspecting on column types
+  module Columns #:nodoc:
+    private
+
+    def is_super(column_family)
+      @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, "comparator_type")
+    end
+
+    def sub_column_name_class(column_family)
+      @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 || klass == DynamicComposite
+            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 || klass == DynamicComposite
+            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
+      end
+    end
+
+    def column_family_property(column_family, key)
+      cfdef = schema.cf_defs.find {|cfdef| cfdef.name == column_family }
+      unless cfdef
+        raise AccessError, "Invalid column family \"#{column_family}\""
+      end
+      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)
+      hash.each do |key, column_or_supercolumn|
+        hash[key] = (column_or_supercolumn.column.value if column_or_supercolumn.column)
+      end
+    end
+
+    def multi_columns_to_hash!(column_family, hash)
+      hash.each do |key, columns|
+        hash[key] = columns_to_hash(column_family, columns)
+      end
+    end
+
+    def multi_sub_columns_to_hash!(column_family, hash)
+      hash.each do |key, sub_columns|
+        hash[key] = sub_columns_to_hash(column_family, sub_columns)
+      end
+    end
+
+    def columns_to_hash(column_family, columns)
+      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_maker(column_family))
+    end
+
+    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::SuperColumn
+          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_maker.call(c.name), c.value, c.timestamp)
+        when CassandraThrift::CounterColumn
+          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
+    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/comparable.rb

@@ -0,0 +1,28 @@
+
+class Cassandra
+  # Abstract base class for comparable numeric column name types
+  class Comparable
+    class TypeError < ::TypeError #:nodoc:
+    end
+  
+    def <=>(other)
+      self.to_i <=> other.to_i
+    end
+    
+    def hash
+      @bytes.hash
+    end
+    
+    def eql?(other)
+      other.is_a?(Comparable) and @bytes == other.to_s
+    end    
+    
+    def ==(other)
+      other.respond_to?(:to_i) && self.to_i == other.to_i
+    end
+    
+    def to_s
+      @bytes
+    end
+  end
+end

data/lib/cassandra/composite.rb

@@ -0,0 +1,137 @@
+class Cassandra
+  class Composite
+    include ::Comparable
+    attr_reader :parts
+    attr_reader :column_slice
+
+    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
+      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
+
+    def pack
+      packed = @parts.map do |part|
+        [part.length].pack('n') + part + "\x00"
+      end
+      if @column_slice
+        part = @parts[-1]
+        packed[-1] = [part.length].pack('n') + part + slice_end_of_component
+      end
+      return packed.join('')
+    end
+
+    def to_s
+      return pack
+    end
+
+    def <=>(other)
+      if !other.instance_of?(self.class)
+        return @parts.first <=> other
+      end
+      eoc = slice_end_of_component.unpack('c')[0]
+      other_eoc = other.slice_end_of_component.unpack('c')[0]
+      @parts.zip(other.parts).each do |a, b|
+        next if a == b
+        if a.nil? && b.nil?
+          return eoc <=> other_eoc
+        end
+
+        if a.nil?
+          return @column_slice == :after ? 1 : -1
+        end
+        if b.nil?
+          return other.column_slice == :after ? -1 : 1
+        end
+        return -1 if a < b
+        return 1 if a > b
+      end
+      return 0
+    end
+
+    def inspect
+      return "#<#{self.class}:#{@column_slice} #{@parts.inspect}>"
+    end
+
+    def slice_end_of_component
+      ret = "\x00"
+      ret = "\x01" if @column_slice == :after
+      ret = "\xFF" if @column_slice == :before
+
+      ret.force_encoding('BINARY') if ret.respond_to?(:force_encoding)
+      return ret
+    end
+
+    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.unpack('n')[0]
+        @parts << packed_string.slice(2, length)
+
+        packed_string.slice!(0, length+3)
+      end
+
+      @column_slice = :after if end_of_component == "\x01"
+      @column_slice = :before if end_of_component == "\xFF"
+    end
+
+    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"
+        end
+
+        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 @hash ||= pack.hash
+    end
+
+    def eql?(other)
+      return to_s == other.to_s
+    end
+  end
+end

data/lib/cassandra/constants.rb

@@ -0,0 +1,11 @@
+
+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
+        
+    Long = Cassandra::Long
+    OrderedHash = Cassandra::OrderedHash
+  end
+end

data/lib/cassandra/debug.rb

@@ -0,0 +1,9 @@
+
+require 'pp'
+
+class CassandraThrift::Cassandra::Client
+  def send_message(*args)
+    pp args
+    super
+  end
+end

data/lib/cassandra/dynamic_composite.rb

@@ -0,0 +1,118 @@
+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[0].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)
+      @hash = packed_string.hash
+
+      @types = []
+      @parts = []
+
+      offset = 0
+      length = nil
+      while offset < packed_string.length
+        if packed_string[offset].ord & 0x80 != 0
+          @types << packed_string[offset+1]
+          offset += 2
+        else
+          length = packed_string.slice(offset, 2).unpack('n')[0]
+          offset += 2
+          @types << packed_string.slice(offset, length)
+          offset += length
+        end
+        length = packed_string.slice(offset, 2).unpack('n')[0]
+        offset += 2
+        @parts << packed_string.slice(offset, length)
+        offset += length + 1
+      end
+
+      @column_slice = :after if packed_string[-1] == "\x01"
+      @column_slice = :before if packed_string[-1] == "\xFF"
+    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