cequel 0.5.6 → 1.0.0.pre.1

data/lib/cequel/metal/deleter.rb

@@ -0,0 +1,47 @@
+module Cequel
+
+  module Metal
+
+    class Deleter < Writer
+
+      def delete_row
+        @delete_row = true
+      end
+
+      def delete_columns(*columns)
+        statements.concat(columns)
+      end
+
+      def list_remove_at(column, *positions)
+        statements.concat(positions.map { |position| "#{column}[#{position}]" })
+      end
+
+      def map_remove(column, *keys)
+        statements.concat(keys.length.times.map { "#{column}[?]" })
+        bind_vars.concat(keys)
+      end
+
+      private
+
+      def write_to_statement(statement)
+        if @delete_row
+          statement.append("DELETE FROM #{table_name}")
+        elsif statements.empty?
+          raise ArgumentError, "No targets given for deletion!"
+        else
+          statement.append("DELETE ").
+            append(statements.join(','), *bind_vars).
+            append(" FROM #{table_name}")
+        end
+        statement.append(generate_upsert_options)
+      end
+
+      def empty?
+        super && !@delete_row
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/metal/incrementer.rb

@@ -0,0 +1,35 @@
+module Cequel
+
+  module Metal
+
+    class Incrementer < Writer
+
+      def increment(data)
+        data.each_pair do |column_name, delta|
+          operator = delta < 0 ? '-' : '+'
+          statements << "#{column_name} = #{column_name} #{operator} ?"
+          bind_vars << delta.abs
+        end
+      end
+
+      def decrement(data)
+        increment(Hash[data.map { |column, count| [column, -count] }])
+      end
+
+      private
+
+      def write_to_statement(statement)
+        statement.
+          append("UPDATE #{table_name}").
+          append(generate_upsert_options).
+          append(
+            " SET " << statements.join(', '),
+            *bind_vars
+        )
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/metal/inserter.rb

@@ -0,0 +1,53 @@
+module Cequel
+
+  module Metal
+
+    class Inserter < Writer
+
+      def initialize(data_set, options = {})
+        @row = {}
+        super
+      end
+
+      def execute
+        statement = Statement.new
+        write_to_statement(statement)
+        data_set.write(*statement.args)
+      end
+
+      def insert(data)
+        @row.merge!(data.symbolize_keys)
+      end
+
+      private
+      attr_reader :row
+
+      def column_names
+        row.keys
+      end
+
+      def statements
+        [].tap do |statements|
+          row.each_pair do |column_name, value|
+            column_names << column_name
+            prepare_upsert_value(value) do |statement, *values|
+              statements << statement
+              bind_vars.concat(values)
+            end
+          end
+        end
+      end
+
+      def write_to_statement(statement)
+        statement.append("INSERT INTO #{table_name}")
+        statement.append(
+          " (#{column_names.join(', ')}) VALUES (#{statements.join(', ')}) ",
+          *bind_vars)
+        statement.append(generate_upsert_options)
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/metal/keyspace.rb

@@ -0,0 +1,213 @@
+module Cequel
+
+  module Metal
+
+    #
+    # Handle to a Cassandra keyspace.
+    #
+    class Keyspace
+
+      #
+      # @api private
+      # @see Cequel.connect
+      #
+      def initialize(configuration={})
+        configure(configuration)
+      end
+
+      def name
+        @keyspace
+      end
+
+      def connection=(connection)
+        @connection = connection
+      end
+
+      def configure(configuration = {})
+        @configuration = configuration
+        @hosts = configuration[:host] || configuration[:hosts]
+        @thrift_options = configuration[:thrift].try(:symbolize_keys) || {}
+        @keyspace = configuration[:keyspace]
+        # reset the connections
+        clear_active_connections!
+      end
+
+      def schema
+        Schema::Keyspace.new(self)
+      end
+
+      def logger=(logger)
+        @logger = logger
+      end
+
+      def logger
+        @logger
+      end
+
+      def slowlog=(slowlog)
+        @slowlog = slowlog
+      end
+
+      def slowlog
+        @slowlog
+      end
+
+      def slowlog_threshold=(slowlog_threshold)
+        @slowlog_threshold = slowlog_threshold
+      end
+
+      def slowlog_threshold
+        @slowlog_threshold
+      end
+
+      def connection_pool
+        return @connection_pool if defined? @connection_pool
+        if @configuration[:pool]
+          options = {
+            :size => @configuration[:pool] || 10,
+            :timeout => @configuration[:pool_timeout] || 5
+          }
+          @connection_pool = ConnectionPool.new(options) do
+            build_connection
+          end
+        else
+          @connection_pool = nil
+        end
+      end
+
+      def connection
+        @connection ||= build_connection
+      end
+
+      def clear_active_connections!
+        remove_instance_variable(:@connection) if defined? @connection
+        remove_instance_variable(:@connection_pool) if defined? @connection_pool
+      end
+
+      def with_connection(&block)
+        if connection_pool
+          connection_pool.with(&block)
+        else
+          yield connection
+        end
+      end
+
+      #
+      # Get DataSet encapsulating a column family in this keyspace
+      #
+      # @param column_family_name [Symbol] the name of the column family
+      # @return [DataSet] a column family
+      #
+      def [](column_family_name)
+        DataSet.new(column_family_name.to_sym, self)
+      end
+
+      #
+      # Execute a CQL query in this keyspace.
+      #
+      # @param statement [String] CQL string
+      # @param *bind_vars [Object] values for bind variables
+      #
+      def execute(statement, *bind_vars)
+        log('CQL', statement, *bind_vars) do
+          with_connection do |conn|
+            conn.execute(statement, *bind_vars)
+          end
+        end
+      end
+
+      #
+      # Write data to this keyspace using a CQL query. Will be included the
+      # current batch operation if one is present.
+      #
+      # @param (see #execute)
+      #
+      def write(statement, *bind_vars)
+        if get_batch
+          get_batch.execute(statement, *bind_vars)
+        else
+          execute(statement, *bind_vars)
+        end
+      end
+
+      #
+      # Execute write operations in a batch. Any inserts, updates, and deletes
+      # inside this method's block will be executed inside a CQL BATCH operation.
+      #
+      # @param options [Hash]
+      # @option options [Fixnum] :auto_apply Automatically send batch to Cassandra after this many statements
+      #
+      # @example Perform inserts in a batch
+      #   DB.batch do
+      #     DB[:posts].insert(:id => 1, :title => 'One')
+      #     DB[:posts].insert(:id => 2, :title => 'Two')
+      #   end
+      #
+      def batch(options = {})
+        old_batch = get_batch
+        new_batch = Batch.new(self, options)
+        set_batch(new_batch)
+        yield
+        new_batch.apply
+      ensure
+        set_batch(old_batch)
+      end
+
+      private
+
+      def build_connection
+        options = {:cql_version => '3.0.0'}
+        options[:keyspace] = @keyspace if @keyspace
+        CassandraCQL::Database.new(
+          @hosts,
+          options,
+          @thrift_options
+        )
+      end
+
+      def get_batch
+        ::Thread.current[batch_key]
+      end
+
+      def set_batch(batch)
+        ::Thread.current[batch_key] = batch
+      end
+
+      def batch_key
+        :"cequel-batch-#{object_id}"
+      end
+
+      def log(label, statement, *bind_vars)
+        return yield unless logger || slowlog
+        response = nil
+        begin
+          time = Benchmark.ms { response = yield }
+        rescue Exception => e
+          generate_message = proc do
+            sprintf(
+              '%s (ERROR) %s', label,
+              CassandraCQL::Statement.sanitize(statement, bind_vars)
+            )
+          end
+          logger.debug(&generate_message) if self.logger
+          raise
+        end
+        generate_message = proc do
+          sprintf(
+            '%s (%dms) %s', label, time.to_i,
+            CassandraCQL::Statement.sanitize(statement, bind_vars)
+          )
+        end
+        logger.debug(&generate_message) if self.logger
+        threshold = self.slowlog_threshold || 2000
+        if slowlog && time >= threshold
+          slowlog.warn(&generate_message)
+        end
+        response
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/metal/row.rb

@@ -0,0 +1,48 @@
+module Cequel
+
+  module Metal
+
+    class Row < ActiveSupport::HashWithIndifferentAccess
+
+      def self.from_result_row(result_row)
+        if result_row
+          new.tap do |row|
+            result_row.column_names.zip(result_row.column_values) do |name, value|
+              if name =~ /^(ttl|writetime)\((.+)\)$/
+                if $1 == 'ttl' then row.set_ttl($2, value)
+                else row.set_writetime($2, value)
+                end
+              else row[name] = value
+              end
+            end
+          end
+        end
+      end
+
+      def initialize(*_)
+        super
+        @ttls = ActiveSupport::HashWithIndifferentAccess.new
+        @writetimes = ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def ttl(column)
+        @ttls[column]
+      end
+
+      def writetime(column)
+        @writetimes[column]
+      end
+
+      def set_ttl(column, value)
+        @ttls[column] = value
+      end
+
+      def set_writetime(column, value)
+        @writetimes[column] = value
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/metal/row_specification.rb

@@ -0,0 +1,37 @@
+module Cequel
+
+  module Metal
+
+    #
+    # @private
+    #
+    class RowSpecification
+
+      def self.build(column_values)
+        column_values.map { |column, value| new(column, value) }
+      end
+
+      attr_reader :column, :value
+
+      def initialize(column, value)
+        @column, @value = column, value
+      end
+
+      def cql
+        case @value
+        when Array
+          if @value.length == 1
+            ["#{@column} = ?", @value.first]
+          else
+            ["#{@column} IN (?)", @value]
+          end
+        else
+          ["#{@column} = ?", @value]
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/metal/statement.rb

@@ -0,0 +1,30 @@
+module Cequel
+
+  module Metal
+
+    class Statement
+      attr_reader :bind_vars
+
+      def initialize
+        @cql, @bind_vars = StringIO.new, []
+      end
+
+      def cql
+        @cql.string
+      end
+
+      def append(cql, *bind_vars)
+        @cql << cql
+        @bind_vars.concat(bind_vars)
+        self
+      end
+
+      def args
+        [cql, *bind_vars]
+      end
+
+    end
+
+  end
+
+end