mcmire-cassandra 0.12.2

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,144 @@
+
+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_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
+      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_class(column_family), sub_column_name_class(column_family))
+    end
+
+    def sub_columns_to_hash(column_family, columns)
+      columns_to_hash_for_classes(columns, sub_column_name_class(column_family))
+    end
+
+    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 || 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/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/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/helpers.rb

@@ -0,0 +1,41 @@
+class Cassandra
+  module Helpers
+    def extract_and_validate_params(column_family, keys, args, options)
+      options = options.dup
+      column_family = column_family.to_s
+      # Keys
+      [keys].flatten.each do |key|
+        raise ArgumentError, "Key #{key.inspect} must be a String for #{caller[2].inspect}." unless key.is_a?(String)
+      end
+
+      # Options
+      if args.last.is_a?(Hash)
+        extras = args.last.keys - options.keys
+        raise ArgumentError, "Invalid options #{extras.inspect[1..-2]} for #{caller[1]}" if extras.any?
+        options.merge!(args.pop)      
+      end
+
+      # 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
+
+      [:start, :finish].each do |opt|
+        options[opt] = options[opt] ? range_class.new(options[opt]).to_s : ''
+      end
+
+      [column_family, s_map(column, klass), s_map(sub_column, sub_klass), options]
+    end
+
+    # Convert stuff to strings.
+    def s_map(el, klass)
+      case el
+      when Array then el.map { |i| s_map(i, klass) }
+      when NilClass then nil
+      else
+        klass.new(el).to_s
+      end
+    end
+  end
+end

data/lib/cassandra/keyspace.rb

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

data/lib/cassandra/long.rb

@@ -0,0 +1,58 @@
+
+class Cassandra
+  # A temporally-ordered Long class for use in Cassandra column names
+  class Long < Comparable
+
+    # FIXME Should unify with or subclass Cassandra::UUID
+    def initialize(bytes = nil)
+      case bytes
+      when self.class # Long
+        @bytes = bytes.to_s
+      when String
+        case bytes.size
+        when 8 # Raw byte array
+          @bytes = bytes
+        when 18 # Human-readable UUID-like representation; inverse of #to_guid
+          elements = bytes.split("-")
+          raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (malformed UUID-like representation)" if elements.size != 3
+          @bytes = [elements.join].pack('H32')
+        else
+          raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (invalid bytecount)"
+        end
+      when Integer
+        raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (integer out of range)" if bytes < 0 or bytes > 2**64
+        @bytes = [bytes >> 32, bytes % 2**32].pack("NN")
+      when NilClass, Time
+        # Time.stamp is 52 bytes, so we have 12 bytes of entropy left over
+        int = ((bytes || Time).stamp << 12) + rand(2**12)
+        @bytes = [int >> 32, int % 2**32].pack("NN")
+      else
+        raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (unknown source class)"
+      end
+    end
+
+    def to_i
+      @to_i ||= begin
+        ints = @bytes.unpack("NN")
+        (ints[0] << 32) +
+        ints[1]
+      end
+    end
+
+    def to_guid
+      "%08x-%04x-%04x" % @bytes.unpack("Nnn")
+    end    
+
+    def inspect
+      "<Cassandra::Long##{object_id} time: #{
+        Time.at((to_i >> 12) / 1_000_000).utc.inspect
+      }, usecs: #{
+        (to_i >> 12) % 1_000_000
+      }, jitter: #{
+        to_i % 2**12
+      }, guid: #{
+        to_guid
+      }>"
+    end
+  end
+end