cassandra 0.2.3 → 0.4

data/lib/cassandra/array.rb

@@ -0,0 +1,8 @@
+
+class Array
+  def _flatten_once
+    result = []
+    each { |el| result.concat(Array(el)) }
+    result
+  end
+end

data/lib/cassandra/cassandra.rb

@@ -0,0 +1,315 @@
+
+class Cassandra
+  include Helper  
+  class AccessError < StandardError; end
+  
+  MAX_INT = 2**31 - 1
+  
+  module Consistency
+    include CassandraThrift::ConsistencyLevel
+    NONE = ZERO
+    WEAK = ONE
+    STRONG = QUORUM
+    PERFECT = ALL
+  end
+  
+  attr_reader :keyspace, :host, :port, :serializer, :transport, :client, :schema
+
+  # Instantiate a new Cassandra and open the connection.
+  def initialize(keyspace, host = '127.0.0.1', port = 9160, serializer = Cassandra::Serialization::JSON)
+    @is_super = {}
+    @column_name_class = {}
+    @sub_column_name_class = {}
+
+    @keyspace = keyspace
+    @host = host
+    @port = port
+    @serializer = serializer
+
+    @transport = Thrift::BufferedTransport.new(Thrift::Socket.new(@host, @port))
+    @transport.open    
+    @client = CassandraThrift::Cassandra::SafeClient.new(
+      CassandraThrift::Cassandra::Client.new(Thrift::BinaryProtocol.new(@transport)), 
+      @transport)
+
+    keyspaces = @client.get_string_list_property("tables")
+    unless keyspaces.include?(@keyspace)
+      raise AccessError, "Keyspace #{@keyspace.inspect} not found. Available: #{keyspaces.inspect}"
+    end
+        
+    @schema = @client.describe_table(@keyspace)    
+  end
+    
+  def inspect
+    "#<Cassandra:#{object_id}, @keyspace=#{keyspace.inspect}, @schema={#{
+      schema.map {|name, hash| ":#{name} => #{hash['type'].inspect}"}.join(', ')
+    }}, @host=#{host.inspect}, @port=#{port}, @serializer=#{serializer.name}>"
+  end
+
+  ## Write
+  
+  # Insert a row for a key. Pass a flat hash for a regular column family, and 
+  # a nested hash for a super column family.
+  def insert(column_family, key, hash, consistency = Consistency::WEAK, timestamp = Time.stamp)
+    column_family = column_family.to_s
+    mutation = if is_super(column_family) 
+      CassandraThrift::BatchMutationSuper.new(:key => key, :cfmap => {column_family.to_s => hash_to_super_columns(column_family, hash, timestamp)})
+    else
+      CassandraThrift::BatchMutation.new(:key => key, :cfmap => {column_family.to_s => hash_to_columns(column_family, hash, timestamp)})      
+    end
+    # FIXME Batched operations discard the consistency argument
+    @batch ? @batch << mutation : _insert(mutation, consistency)
+  end
+  
+  private
+  
+  def _insert(mutation, consistency = Consistency::WEAK)
+    case mutation
+    when CassandraThrift::BatchMutationSuper then @client.batch_insert_super_column(@keyspace, mutation, consistency)    
+    when CassandraThrift::BatchMutation then @client.batch_insert(@keyspace, mutation, consistency)
+    end
+  end  
+  
+  public
+  
+  ## Delete
+  
+  # Remove the element at the column_family:key:[column]:[sub_column]
+  # path you request.
+  def remove(column_family, key, column = nil, sub_column = nil, consistency = Consistency::WEAK, timestamp = Time.stamp)
+    column_family = column_family.to_s
+    assert_column_name_classes(column_family, column, sub_column)
+
+    column = column.to_s if column
+    sub_column = sub_column.to_s if sub_column
+    args = [column_family, key, column, sub_column, consistency, timestamp]
+    @batch ? @batch << args : _remove(*args)
+  end
+  
+  private 
+  
+  def _remove(column_family, key, column, sub_column, consistency, timestamp)
+    column_path_or_parent = if is_super(column_family)
+      CassandraThrift::ColumnPathOrParent.new(:column_family => column_family, :super_column => column, :column => sub_column)
+    else
+      CassandraThrift::ColumnPathOrParent.new(:column_family => column_family, :column => column)
+    end
+    @client.remove(@keyspace, key, column_path_or_parent, timestamp, consistency)
+  end
+   
+  public
+  
+  # Remove all rows in the column family you request.
+  def clear_column_family!(column_family)
+    # Does not support consistency argument
+    get_key_range(column_family).each do |key| 
+      remove(column_family, key)
+    end
+  end
+
+  # Remove all rows in the keyspace
+  def clear_keyspace!
+    # Does not support consistency argument
+    @schema.keys.each do |column_family|
+      clear_column_family!(column_family)
+    end
+  end
+  
+  ## Read
+
+  # Count the elements at the column_family:key:[super_column] path you 
+  # request.
+  def count_columns(column_family, key, super_column = nil, consistency = Consistency::WEAK)
+    column_family = column_family.to_s
+    assert_column_name_classes(column_family, super_column)
+
+    super_column = super_column.to_s if super_column
+    @client.get_column_count(@keyspace, key, 
+      CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => super_column),
+      consistency
+    )
+  end
+  
+  # Multi-key version of Cassandra#count_columns.
+  def multi_count_columns(column_family, keys, super_column = nil, consistency = Consistency::WEAK)
+    OrderedHash[*keys.map do |key|   
+      [key, count_columns(column_family, key, super_column)]
+    end._flatten_once]
+  end  
+  
+  # Return a list of single values for the elements at the
+  # column_family:key:column[s]:[sub_columns] path you request.
+  def get_columns(column_family, key, columns, sub_columns = nil, consistency = Consistency::WEAK)
+    column_family = column_family.to_s
+    assert_column_name_classes(column_family, columns, sub_columns)
+    
+    result = if is_super(column_family) 
+      if sub_columns 
+        columns_to_hash(column_family, @client.get_slice_by_names(@keyspace, key, 
+          CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => columns), 
+          sub_columns, consistency))
+      else
+        columns_to_hash(column_family, @client.get_slice_super_by_names(@keyspace, key, column_family, columns, consistency))      
+      end
+    else
+      columns_to_hash(column_family, @client.get_slice_by_names(@keyspace, key, 
+        CassandraThrift::ColumnParent.new(:column_family => column_family), columns, consistency))
+    end    
+    sub_columns || columns.map { |name| result[name] }
+  end
+
+  # Multi-key version of Cassandra#get_columns.
+  def multi_get_columns(column_family, keys, columns, sub_columns = nil, consistency = Consistency::WEAK)
+    OrderedHash[*keys.map do |key| 
+      [key, get_columns(column_family, key, columns, sub_columns, consistency)]
+    end._flatten_once]
+  end
+        
+  # Return a hash (actually, a Cassandra::OrderedHash) or a single value 
+  # representing the element at the column_family:key:[column]:[sub_column]
+  # path you request.
+  def get(column_family, key, column = nil, sub_column = nil, limit = 100, column_range = ''..'', reversed = false, consistency = Consistency::WEAK)
+    column_family = column_family.to_s
+    assert_column_name_classes(column_family, column, sub_column)    
+    _get(column_family, key, column, sub_column, limit = 100, column_range, reversed, consistency)
+  rescue CassandraThrift::NotFoundException
+    is_super(column_family) && !sub_column ? OrderedHash.new : nil
+  end
+
+  # Multi-key version of Cassandra#get.
+  def multi_get(column_family, keys, column = nil, sub_column = nil, limit = 100, column_range = ''..'', reversed = false, consistency = Consistency::WEAK)
+    OrderedHash[*keys.map do |key| 
+      [key, get(column_family, key, column, sub_column, limit, column_range, reversed, consistency)]
+    end._flatten_once]
+  end
+  
+  # Return true if the column_family:key:[column]:[sub_column] path you 
+  # request exists.
+  def exists?(column_family, key, column = nil, sub_column = nil, consistency = Consistency::WEAK)
+    column_family = column_family.to_s
+    assert_column_name_classes(column_family, column, sub_column)    
+    _get(column_family, key, column, sub_column, 1, ''..'', false, consistency)
+    true
+  rescue CassandraThrift::NotFoundException
+  end
+  
+  private
+  
+  def _get(column_family, key, column = nil, sub_column = nil, limit = 100, column_range = ''..'', reversed = false, consistency = Consistency::WEAK)
+    column = column.to_s if column
+    sub_column = sub_column.to_s if sub_column    
+    # FIXME Comparable types in a are not checked
+    column_range = (column_range.begin.to_s)..(column_range.end.to_s)
+
+    # You have got to be kidding
+    if is_super(column_family)
+      if sub_column
+        # Limit and column_range parameters have no effect
+        load(@client.get_column(@keyspace, key,  
+            CassandraThrift::ColumnPath.new(:column_family => column_family, :super_column => column, :column => sub_column),
+            consistency).value)
+      elsif column
+        sub_columns_to_hash(column_family, 
+          @client.get_slice(@keyspace, key, 
+            CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => column), 
+            column_range.begin, column_range.end, !reversed, limit, consistency))
+      else
+        columns_to_hash(column_family, 
+          @client.get_slice_super(@keyspace, key, column_family, column_range.begin, column_range.end, !reversed, limit, consistency))
+      end
+    else
+      if column
+        # Limit and column_range parameters have no effect
+        load(@client.get_column(@keyspace, key, 
+          CassandraThrift::ColumnPath.new(:column_family => column_family, :column => column),
+          consistency).value)
+      else
+        columns_to_hash(column_family, 
+          @client.get_slice(@keyspace, key, 
+            CassandraThrift::ColumnParent.new(:column_family => column_family), 
+            column_range.begin, column_range.end, !reversed, limit, consistency))
+      end 
+    end
+  end
+  
+  public
+    
+  # Return a list of keys in the column_family you request. Requires the
+  # table to be partitioned with OrderPreservingHash.
+  def get_key_range(column_family, key_range = ''..'', limit = 100, consistency = Consistency::WEAK)      
+    column_family = column_family.to_s
+    @client.get_key_range(@keyspace, column_family, key_range.begin, key_range.end, limit)
+  end
+  
+  # Count all rows in the column_family you request. Requires the table 
+  # to be partitioned with OrderPreservingHash.
+  def count(column_family, key_range = ''..'', limit = MAX_INT, consistency = Consistency::WEAK)
+    get_key_range(column_family, key_range, limit, consistency).size
+  end
+  
+  def batch
+    @batch = []
+    yield    
+    compact_mutations!
+    dispatch_mutations!    
+    @batch = nil
+  end
+  
+  private
+
+  def compact_mutations!
+    compact_batch = []
+    mutations = {}   
+
+    @batch << nil # Close it
+    @batch.each do |m|
+      case m
+      when Array, nil
+        # Flush compacted mutations
+        compact_batch.concat(mutations.values.map {|x| x.values}.flatten)
+        mutations = {}
+        # Insert delete operation
+        compact_batch << m 
+      else # BatchMutation, BatchMutationSuper
+        # Do a nested hash merge
+        if mutation_class = mutations[m.class]
+          if mutation = mutation_class[m.key]
+            if columns = mutation.cfmap[m.cfmap.keys.first]
+              columns.concat(m.cfmap.values.first)
+            else
+              mutation.cfmap.merge!(m.cfmap)
+            end
+          else
+            mutation_class[m.key] = m
+          end
+        else
+          mutations[m.class] = {m.key => m}
+        end
+      end
+    end
+            
+    @batch = compact_batch
+  end
+  
+  def dispatch_mutations!
+    @batch.each do |args| 
+      case args
+      when Array 
+        _remove(*args)
+      when CassandraThrift::BatchMutationSuper, CassandraThrift::BatchMutation 
+        _insert(*args)
+      end
+    end
+  end  
+  
+  def dump(object)
+    # Special-case nil as the empty byte array
+    return "" if object == nil
+    @serializer.dump(object)
+  end
+  
+  def load(object)
+    return nil if object == ""  
+    @serializer.load(object)
+  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
+    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)
+      self.to_i == other.to_i
+    end
+    
+    def to_s
+      @bytes
+    end
+  end
+end

data/lib/cassandra/constants.rb

@@ -0,0 +1,8 @@
+
+class Cassandra
+  module Constants
+    UUID = Cassandra::UUID
+    Long = Cassandra::Long
+    OrderedHash = Cassandra::OrderedHash
+  end
+end

data/lib/cassandra/helper.rb

@@ -0,0 +1,85 @@
+class Cassandra
+
+  # A bunch of crap, mostly related to introspecting on column types
+  module Helper
+  
+    private
+    
+    def is_super(column_family)
+      @is_super[column_family] ||= column_family_property(column_family, 'Type') == "Super"
+    end
+    
+    def column_name_class(column_family)
+      @column_name_class[column_family] ||= column_name_class_for_key(column_family, "CompareWith")
+    end
+    
+    def sub_column_name_class(column_family)
+      @sub_column_name_class[column_family] ||= column_name_class_for_key(column_family, "CompareSubcolumnsWith")
+    end
+    
+    def column_name_class_for_key(column_family, comparator_key)
+      property = column_family_property(column_family, comparator_key)
+      property =~ /.*\.(.*?)Type/
+      self.class.const_get($1) # Long, UUID
+    rescue NameError      
+      String # UTF8, Ascii, Bytes, anything else
+    rescue TypeError
+      nil # Called sub_column_name_class on a standard column family
+    end
+
+    def column_family_property(column_family, key)
+      @schema[column_family][key]
+    rescue NoMethodError
+      raise AccessError, "Invalid column family \"#{column_family}\""    
+    end
+    
+    def assert_column_name_classes(column_family, columns, sub_columns = nil)      
+      {Array(columns) => column_name_class(column_family), 
+        Array(sub_columns) => sub_column_name_class(column_family)}.each do |columns, klass|
+        columns.each do |column|         
+          raise Comparable::TypeError, "Expected #{column.inspect} to be a #{klass}" if !column.is_a?(klass)
+        end 
+      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|
+        hash[column_name_class.new(c.name)] = if c.is_a?(CassandraThrift::SuperColumn)
+          # Pop the class stack, and recurse
+          columns_to_hash_for_classes(c.columns, sub_column_name_class)
+        else
+          load(c.value)
+        end
+      end
+      hash    
+    end
+    
+    def hash_to_columns(column_family, hash, timestamp)
+      assert_column_name_classes(column_family, hash.keys)
+      hash_to_columns_without_assertion(column_family, hash, timestamp)
+    end
+    
+    def hash_to_columns_without_assertion(column_family, hash, timestamp)
+      hash.map do |column, value|
+        CassandraThrift::Column.new(:name => column.to_s, :value => dump(value), :timestamp => timestamp)
+      end    
+    end    
+    
+    def hash_to_super_columns(column_family, hash, timestamp)
+      assert_column_name_classes(column_family, hash.keys)      
+      hash.map do |column, sub_hash|
+        assert_column_name_classes(column_family, nil, sub_hash.keys)
+        CassandraThrift::SuperColumn.new(:name => column.to_s, :columns => hash_to_columns_without_assertion(column_family, sub_hash, timestamp))
+      end
+    end    
+  end
+end