cassilds 0.9.2 → 0.12.1

data/lib/cassandra/0.7/cassandra.rb

@@ -1,272 +1,2 @@
 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/columns.rb

@@ -1,67 +1,4 @@
-
 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
+end

data/lib/cassandra/0.7/protocol.rb

@@ -1,139 +1,5 @@
-
 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.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,23 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../0.7/protocol"
+
+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"