mcmire-cassandra 0.12.2

data/conf/0.8/schema.json

@@ -0,0 +1,66 @@
+{"Twitter":{
+    "Users":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "UserAudits":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "UserCounters":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard",
+      "default_validation_class":"CounterColumnType"},
+    "UserCounterAggregates":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super",
+      "default_validation_class":"CounterColumnType"},
+    "UserRelationships":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super"},
+    "Usernames":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "Statuses":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "StatusAudits":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "StatusRelationships":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super"},
+    "Indexes":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super"},
+    "TimelinishThings":{
+      "comparator_type":"org.apache.cassandra.db.marshal.BytesType",
+      "column_type":"Standard"}
+  },
+"Multiblog":{
+    "Blogs":{
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Standard"},
+    "Comments":{
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Standard"}
+  },
+"MultiblogLong":{
+    "Blogs":{
+      "comparator_type":"org.apache.cassandra.db.marshal.LongType",
+      "column_type":"Standard"},
+    "Comments":{
+      "comparator_type":"org.apache.cassandra.db.marshal.LongType",
+      "column_type":"Standard"}
+  },
+"TypeConversions":{
+    "UUIDColumnConversion":{
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Standard"},
+    "SuperUUID":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Super"}
+  }
+}

data/conf/0.8/schema.txt

@@ -0,0 +1,51 @@
+create keyspace Twitter with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = [{replication_factor:1}];
+use Twitter;
+create column family Users with comparator = 'UTF8Type';
+create column family UserAudits with comparator = 'UTF8Type';
+create column family UserCounters with comparator = 'UTF8Type' and
+  default_validation_class = CounterColumnType;
+create column family UserCounterAggregates with column_type = 'Super'
+  and comparator = 'UTF8Type' and
+  subcomparator = 'UTF8Type' and
+  default_validation_class = CounterColumnType;
+create column family UserRelationships with
+  comparator = 'UTF8Type' and
+  column_type = 'Super' and
+  subcomparator = 'TimeUUIDType';
+create column family Usernames with comparator = 'UTF8Type';
+create column family Statuses with comparator = 'UTF8Type';
+create column family StatusAudits with comparator = 'UTF8Type';
+create column family StatusRelationships with
+  comparator = 'UTF8Type' and
+  column_type = 'Super' and
+  subcomparator = 'TimeUUIDType';
+create column family Indexes with
+  comparator = 'UTF8Type' and
+  column_type = 'Super';
+create column family TimelinishThings with
+  comparator = 'BytesType';
+
+create keyspace Multiblog with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = [{replication_factor:1}];
+use Multiblog;
+create column family Blogs with comparator = 'TimeUUIDType';
+create column family Comments with comparator = 'TimeUUIDType';
+
+
+create keyspace MultiblogLong with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = [{replication_factor:1}];
+use MultiblogLong;
+create column family Blogs with comparator = 'LongType';
+create column family Comments with comparator = 'LongType';
+
+create keyspace TypeConversions with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = [{replication_factor:1}];
+use TypeConversions;
+create column family UUIDColumnConversion with comparator = TimeUUIDType;
+create column family SuperUUID with comparator = TimeUUIDType and column_type = Super;
+

data/lib/cassandra/0.6/cassandra.rb

@@ -0,0 +1,113 @@
+class Cassandra
+  def self.DEFAULT_TRANSPORT_WRAPPER
+    Thrift::BufferedTransport
+  end
+
+  ##
+  # Issues a login attempt using the username and password specified.
+  #
+  # * username
+  # * password
+  #
+  def login!(username, password)
+    @auth_request = CassandraThrift::AuthenticationRequest.new
+    @auth_request.credentials = {'username' => username, 'password' => password}
+    client.login(@keyspace, @auth_request)
+  end
+
+  def inspect
+    "#<Cassandra:#{object_id}, @keyspace=#{keyspace.inspect}, @schema={#{
+      schema(false).map {|name, hash| ":#{name} => #{hash['type'].inspect}"}.join(', ')
+    }}, @servers=#{servers.inspect}>"
+  end
+
+  ##
+  # Returns an array of available keyspaces.
+  #
+  def keyspaces
+    @keyspaces ||= client.describe_keyspaces()
+  end
+
+  ##
+  # Remove all rows in the column family you request.
+  #
+  # * column_family
+  # * options
+  #   * consitency
+  #   * timestamp
+  #
+  def clear_column_family!(column_family, options = {})
+    each_key(column_family) do |key|
+      remove(column_family, key, options)
+    end
+  end
+  alias truncate! clear_column_family!
+
+  # Remove all rows in the keyspace. Supports options <tt>:consistency</tt> and
+  # <tt>:timestamp</tt>.
+  # FIXME May not currently delete all records without multiple calls. Waiting
+  # for ranged remove support in Cassandra.
+  def clear_keyspace!(options = {})
+    schema.keys.each { |column_family| clear_column_family!(column_family, options) }
+  end
+
+  # Open a batch operation and yield self. Inserts and deletes will be queued
+  # until the block closes, and then sent atomically to the server.  Supports
+  # the <tt>:consistency</tt> option, which overrides the consistency set in
+  # the individual commands.
+  def batch(options = {})
+    _, _, _, options = 
+      extract_and_validate_params(schema.keys.first, "", [options], WRITE_DEFAULTS)
+
+    @batch = []
+    yield(self)
+    compacted_map,seen_clevels = compact_mutations!
+    clevel = if options[:consistency] != nil # Override any clevel from individual mutations if 
+               options[:consistency]
+             elsif seen_clevels.length > 1 # Cannot choose which CLevel to use if there are several ones
+               raise "Multiple consistency levels used in the batch, and no override...cannot pick one" 
+             else # if no consistency override has been provided but all the clevels in the batch are the same: use that one
+               seen_clevels.first
+             end
+
+    _mutate(compacted_map,clevel)
+  ensure
+    @batch = nil
+  end
+
+  protected
+
+  def schema(load=true)
+    if !load && !@schema
+      []
+    else
+      @schema ||= client.describe_keyspace(@keyspace)
+    end
+  end
+
+  def client
+    reconnect! if @client.nil?
+    @client
+  end
+
+  def reconnect!
+    @servers = all_nodes
+    @client = new_client
+  end
+
+  def all_nodes
+    if @auto_discover_nodes
+      temp_client = new_client
+      begin
+        ips = ::JSON.parse(temp_client.get_string_property('token map')).values
+        port = @servers.first.split(':').last
+        ips.map{|ip| "#{ip}:#{port}" }
+      ensure 
+        temp_client.disconnect!
+      end
+    else
+      @servers
+    end
+  end
+
+end

data/lib/cassandra/0.6/columns.rb

@@ -0,0 +1,78 @@
+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, '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_family_property(column_family, key)
+      unless schema[column_family]
+        raise AccessError, "Invalid column family \"#{column_family}\""
+      end
+      schema[column_family][key]
+    end
+
+    def _standard_insert_mutation(column_family, column_name, value, timestamp, _=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
+          )
+        )
+      )
+    end
+
+    def _super_insert_mutation(column_family, super_column_name, sub_columns, timestamp, _=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
+              )
+            }
+          )
+        )
+      )
+    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/0.6/protocol.rb

@@ -0,0 +1,90 @@
+
+class Cassandra
+  # Inner methods for actually doing the Thrift calls
+  module Protocol #:nodoc:
+    private
+
+    def _mutate(mutation_map, consistency_level)
+      client.batch_mutate(@keyspace, mutation_map, consistency_level)
+    end
+
+    def _remove(key, column_path, timestamp, consistency_level)
+      client.remove(@keyspace, key, column_path, timestamp, consistency_level)
+    end
+
+    def _count_columns(column_family, key, super_column, consistency)
+      client.get_count(@keyspace, key,
+        CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => super_column),
+        consistency
+      )
+    end
+
+    # FIXME: add support for start, stop, count functionality
+    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(@keyspace, 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(@keyspace, 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(@keyspace, 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
+        column_path = CassandraThrift::ColumnPath.new(:column_family => column_family, :super_column => column, :column => sub_column)
+        multi_column_to_hash!(client.multiget(@keyspace, keys, column_path, consistency))
+      elsif !is_super(column_family) and column
+        column_path = CassandraThrift::ColumnPath.new(:column_family => column_family, :column => column)
+        multi_column_to_hash!(client.multiget(@keyspace, keys, column_path, consistency))
+
+      # 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(@keyspace, keys, column_parent, predicate, consistency))
+        else
+          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+          multi_columns_to_hash!(column_family, client.multiget_slice(@keyspace, keys, column_parent, predicate, consistency))
+        end
+      end
+    end
+
+    def _get_range(column_family, start_key, finish_key, key_count, columns, start, finish, count, consistency)
+      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+      predicate = if columns
+                    CassandraThrift::SlicePredicate.new(:column_names => columns)
+                  else
+                    CassandraThrift::SlicePredicate.new(:slice_range => 
+                      CassandraThrift::SliceRange.new(
+                        :start  => start, 
+                        :finish => finish,
+                        :count  => count))
+                  end
+      range = CassandraThrift::KeyRange.new(:start_key => start_key, :end_key => finish_key, :count => key_count)
+      client.get_range_slices(@keyspace, column_parent, predicate, range, consistency)
+    end
+  end
+end

data/lib/cassandra/0.6.rb

@@ -0,0 +1,7 @@
+class Cassandra
+  def self.VERSION
+    "0.6"
+  end
+end
+
+require "#{File.expand_path(File.dirname(__FILE__))}/../cassandra"

data/lib/cassandra/0.7/cassandra.rb

@@ -0,0 +1,2 @@
+class Cassandra
+end

data/lib/cassandra/0.7/columns.rb

@@ -0,0 +1,4 @@
+class Cassandra
+  module Columns #:nodoc:
+  end
+end

data/lib/cassandra/0.7/protocol.rb

@@ -0,0 +1,5 @@
+class Cassandra
+  # Inner methods for actually doing the Thrift calls
+  module Protocol #:nodoc:
+  end
+end

data/lib/cassandra/0.7.rb

@@ -0,0 +1,7 @@
+class Cassandra
+  def self.VERSION
+    "0.7"
+  end
+end
+
+require "#{File.expand_path(File.dirname(__FILE__))}/../cassandra"

data/lib/cassandra/0.8/cassandra.rb

@@ -0,0 +1,10 @@
+class Cassandra
+
+  ## Counters
+
+  # Add a value to the counter in cf:key:super column:column
+  def add(column_family, key, value, *columns_and_options)
+    column_family, column, sub_column, options = extract_and_validate_params(column_family, key, columns_and_options, WRITE_DEFAULTS)
+    _add(column_family, key, column, sub_column, value, options[:consistency])
+  end
+end

data/lib/cassandra/0.8/columns.rb

@@ -0,0 +1,4 @@
+class Cassandra
+  module Columns #:nodoc:
+  end
+end

data/lib/cassandra/0.8/protocol.rb

@@ -0,0 +1,21 @@
+class Cassandra
+  # Inner methods for actually doing the Thrift calls
+  module Protocol #:nodoc:
+    private
+
+    def _remove_counter(key, column_path, consistency_level)
+      client.remove_counter(key, column_path, consistency_level)
+    end
+
+    def _add(column_family, key, column, sub_column, value, consistency)
+      if is_super(column_family)
+        column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => column)
+        counter_column = CassandraThrift::CounterColumn.new(:name => sub_column, :value => value)
+      else
+        column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+        counter_column = CassandraThrift::CounterColumn.new(:name => column, :value => value)
+      end
+      client.add(key, column_parent, counter_column, consistency)
+    end
+  end
+end

data/lib/cassandra/0.8.rb

@@ -0,0 +1,7 @@
+class Cassandra
+  def self.VERSION
+    "0.8"
+  end
+end
+
+require "#{File.expand_path(File.dirname(__FILE__))}/../cassandra"

data/lib/cassandra/array.rb

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