cequel 0.4.2 → 0.5.0

data/lib/cequel.rb

@@ -1,5 +1,6 @@
 require 'active_support/core_ext'
 require 'cassandra-cql'
+require 'connection_pool'
 
 require 'cequel/batch'
 require 'cequel/errors'

data/lib/cequel/data_set.rb

@@ -60,13 +60,34 @@ module Cequel
         append(generate_upsert_options(options)).
         append(" SET " << data.keys.map { |k| "? = ?" }.join(', '), *data.to_a.flatten).
         append(*row_specifications_cql)
-
       @keyspace.write(*statement.args)
     rescue EmptySubquery
       # Noop -- no rows to update
     end
 
-    # 
+    def increment(data, options = {})
+      operations = data.map do |key, value|
+        operator = value < 0 ? '-' : '+'
+        "? = ? #{operator} ?"
+      end
+      statement = Statement.new.
+        append("UPDATE #{@column_family}").
+        append(generate_upsert_options(options)).
+        append(
+          " SET " << operations.join(', '),
+          *data.flat_map { |column, count| [column, column, count.abs] }
+        ).append(*row_specifications_cql)
+
+      @keyspace.write(*statement.args)
+    end
+    alias_method :incr, :increment
+
+    def decrement(data, options = {})
+      increment(Hash[data.map { |column, count| [column, -count] }], options)
+    end
+    alias_method :decr, :decrement
+
+    #
     # Delete data from the column family
     #
     # @param columns zero or more columns to delete. Deletes the entire row if none specified.

data/lib/cequel/keyspace.rb

@@ -5,25 +5,81 @@ module Cequel
   #
   class Keyspace
 
-    #
-    # Set a logger for logging queries. Queries logged at INFO level
-    #
-    attr_writer :logger, :slowlog, :slowlog_threshold, :connection
-
     #
     # @api private
     # @see Cequel.connect
     #
-    def initialize(configuration = {})
-      @name = configuration[:keyspace]
+    def initialize(configuration={})
+      configure(configuration)
+    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 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],
+          :timeout => configuration[:pool_timeout]
+        }
+        @connection_pool = ConnectionPool.new(:size => 10, :timeout => 5) do
+          build_connection
+        end
+      else
+        @connection_pool = nil
+      end
     end
 
     def connection
-      @connection ||= CassandraCQL::Database.new(
-        @hosts, {:keyspace => @name}, @thrift_options
-      )
+      @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
 
     #
@@ -44,7 +100,9 @@ module Cequel
     #
     def execute(statement, *bind_vars)
       log('CQL', statement, *bind_vars) do
-        connection.execute(statement, *bind_vars)
+        with_connection do |conn|
+          conn.execute(statement, *bind_vars)
+        end
       end
     end
 
@@ -55,8 +113,8 @@ module Cequel
     # @param (see #execute)
     #
     def write(statement, *bind_vars)
-      if @batch
-        @batch.execute(statement, *bind_vars)
+      if get_batch
+        get_batch.execute(statement, *bind_vars)
       else
         execute(statement, *bind_vars)
       end
@@ -76,17 +134,40 @@ module Cequel
     #   end
     #
     def batch(options = {})
-      old_batch, @batch = @batch, Batch.new(self, options)
+      old_batch = get_batch
+      new_batch = Batch.new(self, options)
+      set_batch(new_batch)
       yield
-      @batch.apply
+      new_batch.apply
     ensure
-      @batch = old_batch
+      set_batch(old_batch)
     end
 
     private
 
+    def build_connection
+      options = @keyspace ? {:keyspace => @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
+      return yield unless logger || slowlog
       response = nil
       time = Benchmark.ms { response = yield }
       generate_message = proc do
@@ -95,9 +176,11 @@ module Cequel
           CassandraCQL::Statement.sanitize(statement, bind_vars)
         )
       end
-      @logger.debug(&generate_message) if @logger
-      threshold = @slowlog_threshold || 2000
-      @slowlog.warn(&generate_message) if @slowlog && time >= threshold
+      logger.debug(&generate_message) if self.logger
+      threshold = self.slowlog_threshold || 2000
+      if slowlog && time >= threshold
+        slowlog.warn(&generate_message)
+      end
       response
     end
 

data/lib/cequel/model.rb

@@ -5,6 +5,7 @@ require 'cequel/model/associations'
 require 'cequel/model/callbacks'
 require 'cequel/model/class_internals'
 require 'cequel/model/column'
+require 'cequel/model/counter'
 require 'cequel/model/dictionary'
 require 'cequel/model/dirty'
 require 'cequel/model/dynamic'
@@ -37,6 +38,8 @@ module Cequel
   #
   module Model
 
+    @lock = Monitor.new
+
     extend ActiveSupport::Concern
     extend ActiveModel::Observing::ClassMethods
 
@@ -63,10 +66,12 @@ module Cequel
     end
 
     def self.keyspace
-      @keyspace ||= Cequel.connect(@configuration).tap do |keyspace|
-        keyspace.logger = @logger if @logger
-        keyspace.slowlog = @slowlog if @slowlog
-        keyspace.slowlog_threshold = @slowlog_threshold if @slowlog_threshold
+      @lock.synchronize do
+        @keyspace ||= Cequel.connect(@configuration).tap do |keyspace|
+          keyspace.logger = @logger if @logger
+          keyspace.slowlog = @slowlog if @slowlog
+          keyspace.slowlog_threshold = @slowlog_threshold if @slowlog_threshold
+        end
       end
     end
 

data/lib/cequel/model/class_internals.rb

@@ -7,7 +7,7 @@ module Cequel
     #
     class ClassInternals
 
-      attr_accessor :key, :current_scope, :default_scope
+      attr_accessor :key, :default_scope
       attr_reader :columns, :associations, :index_preference
 
       def initialize(clazz)

data/lib/cequel/model/counter.rb

@@ -0,0 +1,35 @@
+require 'cequel/model/readable_dictionary'
+
+module Cequel
+
+  module Model
+
+    class Counter < ReadableDictionary
+
+      def increment(columns_or_deltas, delta = 1)
+        scope.increment(construct_deltas(columns_or_deltas, delta))
+      end
+
+      def decrement(columns_or_deltas, delta = 1)
+        scope.decrement(construct_deltas(columns_or_deltas, delta))
+      end
+
+      private
+
+      def construct_deltas(columns_or_deltas, delta)
+        if Hash === columns_or_deltas
+          columns_or_deltas
+        else
+          {}.tap do |deltas|
+            Array.wrap(columns_or_deltas).each do |column|
+              deltas[column] = delta
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/dictionary.rb

@@ -1,111 +1,67 @@
+require 'cequel/model/readable_dictionary'
+
 module Cequel
 
   module Model
 
-    class Dictionary
+    class Dictionary < ReadableDictionary
 
       class <<self
 
-        attr_writer :column_family, :default_batch_size
-
-        def key_alias
-          @key_alias ||= :KEY
-        end
-
-        def key_type
-          @key_type ||= :text
-        end
-
-        def comparator
-          @comparator ||= :text
-        end
-
         def validation
           @validation ||= :text
         end
 
-        def key(key_alias, type)
-          @key_alias, @key_type = key_alias, type
-
-          module_eval(<<-RUBY)
-          def #{key_alias.downcase}
-            @key
-          end
-          RUBY
-        end
-
         def maps(options)
           @comparator, @validation = *options.first
         end
 
-        def column_family
-          return @column_family if @column_family
-          self.column_family_name = name.underscore.to_sym
-          @column_family
-        end
-
-        def column_family_name=(column_family_name)
-          self.column_family = Cequel::Model.keyspace[column_family_name]
-        end
-
-        def default_batch_size
-          @default_batch_size || 1000
-        end
-
-        def [](key)
-          new(key)
-        end
-        private :new
       end
 
-      include Enumerable
-
-      def initialize(key)
-        @key = key
-        setup
-      end
-
-      def []=(column, value)
-        if value.nil?
-          @deleted_columns << column
-          @changed_columns.delete(column)
-        else
-          @changed_columns << column
-          @deleted_columns.delete(column)
+      def each_pair(options = {})
+        return super if !block_given? || @loaded
+        new_columns = @changed_columns.dup
+        super do |column, value|
+          if @changed_columns.include?(column)
+            new_columns.delete(column)
+            yield column, @row[column]
+          elsif !@deleted_columns.include?(column)
+            yield column, value
+          end
         end
-        @row[column] = value
+        new_columns.each do |column|
+          yield column, @row[column]
+        end
+        self
       end
 
       def [](column)
         if @loaded || @changed_columns.include?(column)
           @row[column]
         elsif !@deleted_columns.include?(column)
-          value = scope.select(column).first[column]
+          value = super
           deserialize_value(column, value) if value
         end
       end
 
-      def keys
-        @loaded ? @row.keys : each_pair.map { |key, value| key }
-      end
-
-      def values
-        @loaded ? @row.values : each_pair.map { |key, value| value }
-      end
-
       def slice(*columns)
-        if @loaded
-          @row.slice(*columns)
-        else
-          deserialize_row(load_raw_slice(columns)).tap do |slice|
+        super.tap do |slice|
+          unless @loaded
             slice.merge!(@row.slice(*columns))
             @deleted_columns.each { |column| slice.delete(column) }
           end
         end
       end
 
-      def key?(column)
-        @row.key?(column) || load_raw_slice([column])[column].present?
+      def []=(column, value)
+        if value.nil?
+          @deleted_columns << column
+          @changed_columns.delete(column)
+        else
+          @changed_columns << column
+          @deleted_columns.delete(column)
+        end
+        @row[column] = value
       end
 
       def destroy
@@ -125,68 +81,14 @@ module Cequel
         self
       end
 
-      def each_pair(options = {}, &block)
-        return Enumerator.new(self, :each_pair, options) unless block
-        return @row.each_pair(&block) if @loaded
-        new_columns = @changed_columns.dup
-        batch_size = options[:batch_size] || self.class.default_batch_size
-        each_slice(batch_size) do |batch_results|
-          batch_results.each_pair do |key, value|
-            if @changed_columns.include?(key)
-              new_columns.delete(key)
-              yield key, @row[key]
-            elsif !@deleted_columns.include?(key)
-              yield key, value
-            end
-          end
-        end
-        new_columns.each do |key|
-          yield key, @row[key]
-        end
-      end
-
-      def each(&block)
-        each_pair(&block)
-      end
-
-      def each_slice(batch_size)
-        batch_scope = scope.select(:first => batch_size)
-        key_alias = self.class.key_alias
-        last_key = nil
-        begin
-          batch_results = batch_scope.first
-          batch_results.delete(key_alias)
-          result_length = batch_results.length
-          batch_results.delete(last_key) unless last_key.nil?
-          yield deserialize_row(batch_results)
-          last_key = batch_results.keys.last
-          batch_scope = batch_scope.select(:from => last_key)
-        end while result_length == batch_size
-      end
-
-      def load
-        @row = {}
-        each_pair { |column, value| @row[column] = value }
-        @loaded = true
-        self
-      end
-
-      def loaded?
-        !!@loaded
-      end
-
       private
 
-      def setup
-        @row = {}
+      def setup(init_row = nil)
+        super
         @changed_columns = Set[]
         @deleted_columns = Set[]
       end
 
-      def scope
-        self.class.column_family.where(self.class.key_alias => @key)
-      end
-
       #
       # Subclasses may override this method to implement custom serialization
       # strategies
@@ -211,10 +113,6 @@ module Cequel
         end
       end
 
-      def load_raw_slice(columns)
-        row = scope.select(*columns).first.except(self.class.key_alias)
-      end
-
     end
 
   end