cequel 0.5.6 → 1.0.0.pre.1

data/lib/cequel/keyspace.rb

@@ -1,205 +0,0 @@
-module Cequel
-
-  #
-  # Handle to a Cassandra keyspace.
-  #
-  class Keyspace
-
-    #
-    # @api private
-    # @see Cequel.connect
-    #
-    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 with_consistency(consistency)
-      previous_consistency = default_consistency
-      Thread.current[consistency_key] = consistency
-      yield
-    ensure
-      Thread.current[consistency_key] = previous_consistency
-    end
-
-    def default_consistency
-      Thread.current[consistency_key]
-    end
-
-    def consistency_key
-      "Cequel::Keyspace[#{object_id}]#default_consistency"
-    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 = @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
-      response = nil
-      time = Benchmark.ms { response = yield }
-      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

data/lib/cequel/model/class_internals.rb

@@ -1,49 +0,0 @@
-module Cequel
-
-  module Model
-
-    #
-    # @private
-    #
-    class ClassInternals
-
-      attr_accessor :key, :default_scope
-      attr_reader :columns, :associations, :index_preference
-      attr_writer :column_family_name
-
-      def initialize(clazz)
-        @clazz = clazz
-        @columns, @associations = {}, {}
-        @index_preference = []
-        @lock = Monitor.new
-      end
-
-      def add_column(name, type, options = {})
-        @columns[name] = Column.new(name, type, options)
-      end
-
-      def type_column
-        @columns[:class_name]
-      end
-
-      def column_family_name
-        @column_family_name ||= @clazz.name.tableize
-      end
-
-      def base_class
-        @clazz
-      end
-
-      def association(name)
-        associations[name]
-      end
-
-      def synchronize(&block)
-        @lock.synchronize(&block)
-      end
-
-    end
-
-  end
-
-end

data/lib/cequel/model/column.rb

@@ -1,20 +0,0 @@
-module Cequel
-
-  module Model
-
-    #
-    # Encapsulates information about a column in a model's column family
-    #
-    class Column
-      attr_reader :name, :type, :default
-
-      def initialize(name, type, options = {})
-        @name, @type = name, type
-        @default = options[:default]
-      end
-
-    end
-
-  end
-
-end

data/lib/cequel/model/counter.rb

@@ -1,35 +0,0 @@
-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,126 +0,0 @@
-require 'cequel/model/readable_dictionary'
-
-module Cequel
-
-  module Model
-
-    class Dictionary < ReadableDictionary
-
-      class <<self
-
-        def validation
-          @validation ||= :text
-        end
-
-        def maps(options)
-          @comparator, @validation = *options.first
-        end
-
-      end
-
-      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
-        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 = super
-          deserialize_value(column, value) if value
-        end
-      end
-
-      def slice(*columns)
-        super.tap do |slice|
-          unless @loaded
-            slice.merge!(@row.slice(*columns))
-            @deleted_columns.each { |column| slice.delete(column) }
-          end
-        end
-      end
-
-      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
-        scope.delete
-        setup
-      end
-
-      def save
-        batch_size = self.class.default_batch_size
-        @changed_columns.each_slice(batch_size) do |slice|
-          updates = {}
-          slice.each do |column|
-            updates[column] = serialize_value(@row[column])
-          end
-          scope.update(updates) if updates.any?
-        end
-        @deleted_columns.each_slice(batch_size) do |slice|
-          scope.delete(*slice.to_a) if slice.any?
-        end
-        @row.clear unless @loaded
-        @changed_columns.clear
-        @deleted_columns.clear
-        self
-      end
-
-      private
-
-      def setup(init_row = nil)
-        super
-        @changed_columns = Set[]
-        @deleted_columns = Set[]
-      end
-
-      #
-      # Subclasses may override this method to implement custom serialization
-      # strategies
-      #
-      def serialize_value(value)
-        value
-      end
-
-      #
-      # Subclasses may override this method to implement custom deserialization
-      # strategies
-      #
-      def deserialize_value(column, value)
-        value
-      end
-
-      def deserialize_row(row)
-        {}.tap do |slice|
-          row.each_pair do |column, value|
-            slice[column] = deserialize_value(column, value)
-          end
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/cequel/model/dirty.rb

@@ -1,53 +0,0 @@
-module Cequel
-
-  module Model
-
-    module Dirty
-
-      extend ActiveSupport::Concern
-
-      included do
-        include ActiveModel::Dirty
-        include ChangedAttributesWithIndifferentAccess
-      end
-
-      module ClassMethods
-
-        def column(name, type, options = {})
-          define_attribute_method(name)
-          super
-        end
-
-      end
-
-      def save
-        super.tap do
-          @previously_changed = changes
-          changed_attributes.clear
-        end
-      end
-
-      def _hydrate(row)
-        super.tap { changed_attributes.clear }
-      end
-
-      private
-
-      def write_attribute(name, value)
-        attribute_will_change!(name) if value != read_attribute(name)
-        super
-      end
-
-    end
-
-    module ChangedAttributesWithIndifferentAccess
-
-      def changed_attributes
-        @changed_attributes ||= HashWithIndifferentAccess.new
-      end
-
-    end
-
-  end
-
-end