cequel 0.0.0 → 0.4.0

data/lib/cequel/keyspace.rb

@@ -0,0 +1,106 @@
+module Cequel
+
+  #
+  # Handle to a Cassandra keyspace.
+  #
+  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]
+      @hosts = configuration[:host] || configuration[:hosts]
+      @thrift_options = configuration[:thrift].try(:symbolize_keys)
+    end
+
+    def connection
+      @connection ||= CassandraCQL::Database.new(
+        @hosts, {:keyspace => @name}, @thrift_options
+      )
+    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
+        connection.execute(statement, *bind_vars)
+      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 @batch
+        @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, @batch = @batch, Batch.new(self, options)
+      yield
+      @batch.apply
+    ensure
+      @batch = old_batch
+    end
+
+    private
+
+    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 @logger
+      threshold = @slowlog_threshold || 2000
+      @slowlog.warn(&generate_message) if @slowlog && time >= threshold
+      response
+    end
+
+  end
+
+end

data/lib/cequel/model.rb

@@ -0,0 +1,95 @@
+require 'active_model'
+
+require 'cequel'
+require 'cequel/model/associations'
+require 'cequel/model/callbacks'
+require 'cequel/model/class_internals'
+require 'cequel/model/column'
+require 'cequel/model/dictionary'
+require 'cequel/model/dirty'
+require 'cequel/model/dynamic'
+require 'cequel/model/errors'
+require 'cequel/model/inheritable'
+require 'cequel/model/instance_internals'
+require 'cequel/model/local_association'
+require 'cequel/model/mass_assignment_security'
+require 'cequel/model/magic'
+require 'cequel/model/naming'
+require 'cequel/model/observer'
+require 'cequel/model/persistence'
+require 'cequel/model/properties'
+require 'cequel/model/remote_association'
+require 'cequel/model/scope'
+require 'cequel/model/scoped'
+require 'cequel/model/subclass_internals'
+require 'cequel/model/timestamps'
+require 'cequel/model/translation'
+require 'cequel/model/validations'
+
+if defined? Rails
+  require 'cequel/model/railtie'
+end
+
+module Cequel
+
+  #
+  # This module adds Cassandra persistence to a class using Cequel.
+  #
+  module Model
+
+    extend ActiveSupport::Concern
+    extend ActiveModel::Observing::ClassMethods
+
+    included do
+      @_cequel = ClassInternals.new(self)
+
+      include Properties
+      include Persistence
+      include Scoped
+      include Naming
+      include Callbacks
+      include Validations
+      include ActiveModel::Observing
+      include Dirty
+      include MassAssignmentSecurity
+      include Associations
+      extend Inheritable
+      extend Magic
+
+      include ActiveModel::Serializers::JSON
+      include ActiveModel::Serializers::Xml
+
+      extend Translation
+    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
+      end
+    end
+
+    def self.configure(configuration)
+      @configuration = configuration
+    end
+
+    def self.logger=(logger)
+      @logger = logger
+    end
+
+    def self.slowlog=(slowlog)
+      @slowlog = slowlog
+    end
+
+    def self.slowlog_threshold=(slowlog_threshold)
+      @slowlog_threshold = slowlog_threshold
+    end
+
+    def initialize
+      @_cequel = InstanceInternals.new(self)
+    end
+
+  end
+
+end

data/lib/cequel/model/associations.rb

@@ -0,0 +1,120 @@
+module Cequel
+
+  module Model
+
+    module Associations
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def belongs_to(name, options = {})
+          name = name.to_sym
+          association = LocalAssociation.new(name, self, options.symbolize_keys)
+          @_cequel.associations[name] = association
+          column(association.foreign_key_name, association.primary_key.type)
+
+          module_eval <<-RUBY, __FILE__, __LINE__+1
+            def #{name}
+              if @_cequel.associations.key?(#{name.inspect})
+                return @_cequel.associations[#{name.inspect}]
+              end
+              key = __send__(:#{name}_id)
+              if key
+                @_cequel.associations[#{name.inspect}] =
+                  self.class.reflect_on_association(#{name.inspect}).
+                    scope(self).first
+              else
+                @_cequel.associations[#{name.inspect}] = nil
+              end
+            end
+
+            def #{name}=(instance)
+              @_cequel.associations[#{name.inspect}] = instance
+              if instance.nil?
+                key = nil
+              else
+                key = instance.__send__(instance.class.key_alias)
+              end
+              write_attribute(#{association.foreign_key_name.inspect}, key)
+            end
+
+            def #{association.foreign_key_name}=(key)
+              @_cequel.associations.delete(#{name.inspect})
+              write_attribute(#{association.foreign_key_name.inspect}, key)
+            end
+          RUBY
+        end
+
+        def has_many(name, options = {})
+          name = name.to_sym
+          @_cequel.associations[name] =
+            RemoteAssociation.new(name, self, options.symbolize_keys)
+          
+          module_eval <<-RUBY, __FILE__, __LINE__+1
+            def #{name}
+              self.class.reflect_on_association(#{name.inspect}).scope(self)
+            end
+          RUBY
+        end
+
+        def has_one(name, options = {})
+          name = name.to_sym
+          @_cequel.associations[name] =
+            RemoteAssociation.new(name, self, options.symbolize_keys)
+
+          module_eval <<-RUBY, __FILE__, __LINE__+1
+            def #{name}
+              self.class.reflect_on_association(#{name.inspect}).scope(self).first
+            end
+          RUBY
+        end
+
+        def reflect_on_association(name)
+          @_cequel.association(name.to_sym)
+        end
+
+        def reflect_on_associations
+          @_cequel.associations.values
+        end
+
+      end
+
+      def save(*args)
+        save_transient_associated
+        super
+      end
+
+      def destroy(*args)
+        destroy_associated
+        super
+      end
+
+      private
+
+      def save_transient_associated
+        self.class.reflect_on_associations.each do |association|
+          if LocalAssociation === association
+            associated = @_cequel.associations[association.name]
+            if associated && associated.transient?
+              associated.save
+            end
+          end
+        end
+      end
+
+      def destroy_associated
+        self.class.reflect_on_associations.each do |association|
+          if association.dependent == :destroy
+            association.scope(self).each do |associated|
+              associated.destroy
+            end
+          end
+        end
+      end
+
+    end
+    
+  end
+
+end

data/lib/cequel/model/callbacks.rb

@@ -0,0 +1,32 @@
+module Cequel
+
+  module Model
+
+    module Callbacks
+
+      extend ActiveSupport::Concern
+
+      HOOKS = [:save, :create, :update, :destroy, :validation]
+      CALLBACKS = HOOKS.map { |hook| [:"before_#{hook}", :"after_#{hook}"] }.
+        flatten
+
+      included do
+        extend ActiveModel::Callbacks
+        define_model_callbacks *HOOKS
+      end
+
+      def save(*args)
+        run_callbacks(:save) do
+          run_callbacks(persisted? ? :update : :create) { super }
+        end
+      end
+
+      def destroy(*args)
+        run_callbacks(:destroy) { super }
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/class_internals.rb

@@ -0,0 +1,48 @@
+module Cequel
+
+  module Model
+
+    #
+    # @private
+    #
+    class ClassInternals
+
+      attr_accessor :key, :current_scope, :default_scope
+      attr_reader :columns, :associations, :index_preference
+
+      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

@@ -0,0 +1,20 @@
+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/dictionary.rb

@@ -0,0 +1,202 @@
+module Cequel
+
+  module Model
+
+    class Dictionary
+
+      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)
+        end
+        @row[column] = value
+      end
+
+      def [](column)
+        if @loaded || @changed_columns.include?(column)
+          @row[column]
+        elsif !@deleted_columns.include?(column)
+          value = scope.select(column).first[column]
+          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
+          {}.tap do |slice|
+            row = scope.select(*columns).first.except(self.class.key_alias)
+            row.each { |col, value| slice[col] = deserialize_value(col, value) }
+            slice.merge!(@row.slice(*columns))
+            @deleted_columns.each { |column| slice.delete(column) }
+          end
+        end
+      end
+
+      def destroy
+        scope.delete
+        setup
+      end
+
+      def save
+        updates = {}
+        @changed_columns.each do |column|
+          updates[column] = serialize_value(@row[column])
+        end
+        scope.update(updates) if updates.any?
+        scope.delete(*@deleted_columns.to_a) if @deleted_columns.any?
+        @changed_columns.clear
+        @deleted_columns.clear
+        self
+      end
+
+      def each_pair(options = {}, &block)
+        return Enumerator.new(self, :each_pair, options) unless block
+        return @row.each_pair(&block) if @loaded
+        batch_size = options[:batch_size] || self.class.default_batch_size
+        batch_scope = scope.select(:first => batch_size)
+        key_alias = self.class.key_alias
+        last_key = nil
+        new_columns = @changed_columns.dup
+        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?
+          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, deserialize_value(key, value)
+            end
+          end
+          last_key = batch_results.keys.last
+          batch_scope = batch_scope.select(:from => last_key)
+        end while result_length == batch_size
+        new_columns.each do |key|
+          yield key, @row[key]
+        end
+      end
+
+      def each(&block)
+        each_pair(&block)
+      end
+
+      def load
+        @row = {}
+        each_pair { |column, value| @row[column] = value }
+        @loaded = true
+        self
+      end
+
+      def loaded?
+        !!@loaded
+      end
+
+      private
+
+      def setup
+        @row = {}
+        @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
+      #
+      def serialize_value(value)
+        value
+      end
+
+      #
+      # Subclasses may override this method to implement custom deserialization
+      # strategies
+      #
+      def deserialize_value(column, value)
+        value
+      end
+
+    end
+
+  end
+
+end