cassilds 0.9.1

data/lib/cassandra/0.7/cassandra.rb

@@ -0,0 +1,272 @@
+class Cassandra
+
+  def self.DEFAULT_TRANSPORT_WRAPPER
+    Thrift::FramedTransport
+  end
+
+  def login!(username, password)
+    @auth_request = CassandraThrift::AuthenticationRequest.new
+    @auth_request.credentials = {'username' => username, 'password' => password}
+    client.login(@auth_request)
+  end
+
+  def inspect
+    "#<Cassandra:#{object_id}, @keyspace=#{keyspace.inspect}, @schema={#{
+      Array(schema(false).cf_defs).map {|cfdef| ":#{cfdef.name} => #{cfdef.column_type}"}.join(', ')
+    }}, @servers=#{servers.inspect}>"
+  end
+
+  def keyspace=(ks)
+    client.set_keyspace(ks)
+    @schema = nil; @keyspace = ks
+  end
+
+  def keyspaces
+    client.describe_keyspaces.to_a.collect {|ksdef| ksdef.name }
+  end
+
+  def schema(load=true)
+    if !load && !@schema
+      Cassandra::Keyspace.new
+    else
+      @schema ||= client.describe_keyspace(@keyspace)
+    end
+  end
+
+  def schema_agreement?
+    client.describe_schema_versions().length == 1
+  end
+
+  def version
+    client.describe_version()
+  end
+
+  def cluster_name
+    @cluster_name ||= client.describe_cluster_name()
+  end
+
+  def ring
+    client.describe_ring(@keyspace)
+  end
+
+  def partitioner
+    client.describe_partitioner()
+  end
+
+  ## Delete
+
+  # Remove all rows in the column family you request.
+  def truncate!(column_family)
+    #each_key(column_family) do |key|
+    #  remove(column_family, key, options)
+    #end
+    client.truncate(column_family)
+  end
+
+  # Remove all rows in the keyspace.
+  def clear_keyspace!
+    schema.cf_defs.each { |cfdef| truncate!(cfdef.name) }
+  end
+
+### Read
+
+  def add_column_family(cf_def)
+    begin
+      res = client.system_add_column_family(cf_def)
+    rescue CassandraThrift::TimedOutException => te
+      puts "Timed out: #{te.inspect}"
+    end
+    @schema = nil
+    res
+  end
+
+  def drop_column_family(cf_name)
+    begin
+      res = client.system_drop_column_family(cf_name)
+    rescue CassandraThrift::TimedOutException => te
+      puts "Timed out: #{te.inspect}"
+    end
+    @schema = nil
+    res
+  end
+
+  def rename_column_family(old_name, new_name)
+    begin
+      res = client.system_rename_column_family(old_name, new_name)
+    rescue CassandraThrift::TimedOutException => te
+      puts "Timed out: #{te.inspect}"
+    end
+    @schema = nil
+    res
+  end
+
+  def update_column_family(cf_def)
+    begin
+      res = client.system_update_column_family(cf_def)
+    rescue CassandraThrift::TimedOutException => te
+      puts "Timed out: #{te.inspect}"
+    end
+    @schema = nil
+    res
+  end
+
+  def add_keyspace(ks_def)
+    begin
+      res = client.system_add_keyspace(ks_def)
+    rescue CassandraThrift::TimedOutException => toe
+      puts "Timed out: #{toe.inspect}"
+    rescue Thrift::TransportException => te
+      puts "Timed out: #{te.inspect}"
+    end
+    @keyspaces = nil
+    res
+  end
+
+  def drop_keyspace(ks_name)
+    begin
+      res = client.system_drop_keyspace(ks_name)
+    rescue CassandraThrift::TimedOutException => toe
+      puts "Timed out: #{toe.inspect}"
+    rescue Thrift::TransportException => te
+      puts "Timed out: #{te.inspect}"
+    end
+    keyspace = "system" if ks_name.eql?(@keyspace)
+    @keyspaces = nil
+    res
+  end
+
+  def rename_keyspace(old_name, new_name)
+    begin
+      res = client.system_rename_keyspace(old_name, new_name)
+    rescue CassandraThrift::TimedOutException => toe
+      puts "Timed out: #{toe.inspect}"
+    rescue Thrift::TransportException => te
+      puts "Timed out: #{te.inspect}"
+    end
+    keyspace = new_name if old_name.eql?(@keyspace)
+    @keyspaces = nil
+    res
+  end
+
+  def update_keyspace(ks_def)
+    begin
+      res = client.system_update_keyspace(ks_def)
+    rescue CassandraThrift::TimedOutException => toe
+      puts "Timed out: #{toe.inspect}"
+    rescue Thrift::TransportException => te
+      puts "Timed out: #{te.inspect}"
+    end
+    @keyspaces = nil
+    res
+  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.cf_defs.first.name, "", [options], WRITE_DEFAULTS)
+
+    @batch = []
+    yield(self)
+    compact_mutations!
+
+    @batch.each do |mutation|
+      case mutation.first
+      when :remove
+        _remove(*mutation[1])
+      else
+        _mutate(*mutation)
+      end
+    end
+  ensure
+    @batch = nil
+  end
+
+### 2ary Indexing
+
+  def create_index(ks_name, cf_name, c_name, v_class)
+    cf_def = client.describe_keyspace(ks_name).cf_defs.find{|x| x.name == cf_name}
+    if !cf_def.nil? and !cf_def.column_metadata.find{|x| x.name == c_name}
+      c_def  = CassandraThrift::ColumnDef.new do |cd|
+        cd.name             = c_name
+        cd.validation_class = "org.apache.cassandra.db.marshal."+v_class
+        cd.index_type       = CassandraThrift::IndexType::KEYS
+      end
+      cf_def.column_metadata.push(c_def)
+      update_column_family(cf_def)
+    end
+  end
+
+  def drop_index(ks_name, cf_name, c_name)
+    cf_def = client.describe_keyspace(ks_name).cf_defs.find{|x| x.name == cf_name}
+    if !cf_def.nil? and cf_def.column_metadata.find{|x| x.name == c_name}
+      cf_def.column_metadata.delete_if{|x| x.name == c_name}
+      update_column_family(cf_def)
+    end
+  end
+
+	def create_idx_expr(c_name, value, op)
+		CassandraThrift::IndexExpression.new(
+			:column_name => c_name,
+			:value => value,
+			:op => (case op
+								when nil, "EQ", "eq", "=="
+									CassandraThrift::IndexOperator::EQ
+								when "GTE", "gte", ">="
+									CassandraThrift::IndexOperator::GTE
+								when "GT", "gt", ">"
+									CassandraThrift::IndexOperator::GT
+								when "LTE", "lte", "<="
+									CassandraThrift::IndexOperator::LTE
+								when "LT", "lt", "<"
+									CassandraThrift::IndexOperator::LT
+							end ))
+	end
+
+	def create_idx_clause(idx_expressions, start = "")
+		CassandraThrift::IndexClause.new(
+			:start_key => start,
+			:expressions => idx_expressions)
+	end
+
+  # TODO: Supercolumn support.
+  def get_indexed_slices(column_family, idx_clause, *columns_and_options)
+    column_family, columns, _, options =
+      extract_and_validate_params(column_family, [], columns_and_options, READ_DEFAULTS)
+    _get_indexed_slices(column_family, idx_clause, columns, options[:count], options[:start],
+      options[:finish], options[:reversed], options[:consistency])
+  end
+
+  protected
+
+  def client
+    if @client.nil? || @client.current_server.nil?
+      reconnect!
+      @client.set_keyspace(@keyspace)
+    end
+    @client
+  end
+
+  def reconnect!
+    @servers = all_nodes
+    @client = new_client
+  end
+
+  def all_nodes
+    if @auto_discover_nodes && !@keyspace.eql?("system")
+      temp_client = new_client
+      begin
+        ips = (temp_client.describe_ring(@keyspace).map {|range| range.endpoints}).flatten.uniq
+        port = @servers.first.split(':').last
+        ips.map{|ip| "#{ip}:#{port}" }
+      ensure
+        temp_client.disconnect!
+      end
+    else
+      @servers
+    end
+  end
+
+end

data/lib/cassandra/0.7/column_family.rb

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

data/lib/cassandra/0.7/columns.rb

@@ -0,0 +1,67 @@
+
+class Cassandra
+  # A bunch of crap, mostly related to introspecting on column types
+  module Columns #:nodoc:
+
+    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_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 keyslice_to_hash(column_family, slice_array)
+      hash = OrderedHash.new
+      slice_array.each { |slice|
+        hash[slice.key] = columns_to_hash(column_family, slice.columns)
+      }
+      hash
+    end
+
+    private
+
+    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
+  end
+end

data/lib/cassandra/0.7/keyspace.rb

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

data/lib/cassandra/0.7/protocol.rb

@@ -0,0 +1,139 @@
+
+class Cassandra
+  # Inner methods for actually doing the Thrift calls
+  module Protocol #:nodoc:
+    private
+
+    def _mutate(mutation_map, consistency_level)
+      client.batch_mutate(mutation_map, consistency_level)
+    end
+
+    def _remove(key, column_path, timestamp, consistency_level)
+      client.remove(key, column_path, timestamp, consistency_level)
+    end
+
+    def _count_columns(column_family, key, super_column, consistency)
+      client.get_count(key,
+        CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => super_column),
+        consistency
+      )
+    end
+
+    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(key,
+              CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => columns),
+              CassandraThrift::SlicePredicate.new(:column_names => Array(sub_columns)),
+              consistency))
+        else
+          columns_to_hash(column_family, client.get_slice(key,
+              CassandraThrift::ColumnParent.new(:column_family => column_family),
+              CassandraThrift::SlicePredicate.new(:column_names => Array(columns)),
+              consistency))
+        end
+      else
+        columns_to_hash(column_family, client.get_slice(key,
+            CassandraThrift::ColumnParent.new(:column_family => column_family),
+            CassandraThrift::SlicePredicate.new(:column_names => Array(columns)),
+            consistency))
+      end
+    end
+
+    def _multiget(column_family, keys, column, sub_column, start, finish, count, reversed, consistency)
+      # Single values; count and range parameters have no effect
+      if is_super(column_family) and sub_column
+        predicate = CassandraThrift::SlicePredicate.new(:column_names => Array(column))
+        column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => column)
+        multi_sub_columns_to_hash!(column_family, client.multiget_slice(keys, column_parent, predicate, consistency))
+
+      elsif !is_super(column_family) and column
+        predicate = CassandraThrift::SlicePredicate.new(:column_names => Array(column))
+        column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+        multi_columns_to_hash!(column_family, client.multiget_slice(keys, column_parent, predicate, 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(keys, column_parent, predicate, consistency))
+        else
+          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+          multi_columns_to_hash!(column_family, client.multiget_slice(keys, column_parent, predicate, consistency))
+        end
+      end
+    end
+
+    def _get_range(column_family, start, finish, count, consistency)
+      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+      predicate = CassandraThrift::SlicePredicate.new(:slice_range => CassandraThrift::SliceRange.new(:start => '', :finish => '', :count => count*10))
+      range = CassandraThrift::KeyRange.new(:start_key => start, :end_key => finish, :count => count)
+      client.get_range_slices(column_parent, predicate, range, consistency)
+    end
+
+    def _get_range_hash(column_family, start, finish, count, consistency)
+      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+      predicate = CassandraThrift::SlicePredicate.new(:slice_range => CassandraThrift::SliceRange.new(:start => '', :finish => ''))
+      range = CassandraThrift::KeyRange.new(:start_key => start, :end_key => finish, :count => count)
+      result = client.get_range_slices(column_parent, predicate, range, consistency)
+      keyslice_to_hash column_family, result
+    end
+
+    def _get_range_columns(column_family, columns, sub_columns, start, finish, count, consistency)
+      result = if is_super(column_family)
+        column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+        predicate = if sub_columns
+          CassandraThrift::SlicePredicate.new(:column_names => Array(sub_columns))
+        else
+          CassandraThrift::SlicePredicate.new(:slice_range => CassandraThrift::SliceRange.new(:start => '', :finish => ''))
+        end
+        range = CassandraThrift::KeyRange.new(:start_key => start, :end_key => finish, :count => count)
+        client.get_range_slices(column_parent, predicate, range, consistency)
+      else
+        column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+        predicate = if columns
+          CassandraThrift::SlicePredicate.new(:column_names => Array(columns))
+        else
+          CassandraThrift::SlicePredicate.new(:slice_range => CassandraThrift::SliceRange.new(:start => '', :finish => ''))
+        end
+        range = CassandraThrift::KeyRange.new(:start_key => start, :end_key => finish, :count => count)
+        client.get_range_slices(column_parent, predicate, range, consistency)
+      end
+      keyslice_to_hash(column_family, result)
+    end
+
+    def _get_range_keys(column_family, start, finish, count, consistency)
+      _get_range(column_family, start, finish, count, consistency).collect{|i| i.key }
+    end
+
+    # TODO: Supercolumn support
+    def _get_indexed_slices(column_family, idx_clause, column, count, start, finish, reversed, consistency)
+      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+      if column
+        predicate = CassandraThrift::SlicePredicate.new(:column_names => [column])
+      else
+        predicate = CassandraThrift::SlicePredicate.new(:slice_range =>
+            CassandraThrift::SliceRange.new(
+            :reversed => reversed,
+            :count => count,
+            :start => start,
+            :finish => finish))
+      end
+      client.get_indexed_slices(column_parent, idx_clause, predicate, consistency)
+    end
+
+    def each_key(column_family)
+      column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family.to_s)
+      predicate = CassandraThrift::SlicePredicate.new(:column_names => [])
+      range = CassandraThrift::KeyRange.new(:start_key => '', :end_key => '')
+      client.get_range_slices(column_parent, predicate, range, 1).each{|i| yield i.key }
+    end
+  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/array.rb

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