cequel 0.5.6 → 1.0.0.pre.1

data/lib/cequel/metal/updater.rb

@@ -0,0 +1,65 @@
+module Cequel
+
+  module Metal
+
+    class Updater < Writer
+
+      def set(data)
+        data.each_pair do |column, value|
+          prepare_upsert_value(value) do |binding, *values|
+            statements << "#{column} = #{binding}"
+            bind_vars.concat(values)
+          end
+        end
+      end
+
+      def list_prepend(column, elements)
+        statements << "#{column} = [?] + #{column}"
+        bind_vars << elements
+      end
+
+      def list_append(column, elements)
+        statements << "#{column} = #{column} + [?]"
+        bind_vars << elements
+      end
+
+      def list_remove(column, value)
+        statements << "#{column} = #{column} - [?]"
+        bind_vars << value
+      end
+
+      def list_replace(column, index, value)
+        statements << "#{column}[#{index}] = ?"
+        bind_vars << value
+      end
+
+      def set_add(column, values)
+        statements << "#{column} = #{column} + {?}"
+        bind_vars << values
+      end
+
+      def set_remove(column, value)
+        statements << "#{column} = #{column} - {?}"
+        bind_vars << ::Kernel.Array(value)
+      end
+
+      def map_update(column, updates)
+        binding_pairs = ::Array.new(updates.length) { '?:?' }.join(',')
+        statements << "#{column} = #{column} + {#{binding_pairs}}"
+        bind_vars.concat(updates.flatten)
+      end
+
+      private
+
+      def write_to_statement(statement)
+        statement.append("UPDATE #{table_name}").
+          append(generate_upsert_options).
+          append(" SET ").
+          append(statements.join(', '), *bind_vars)
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/metal/writer.rb

@@ -0,0 +1,73 @@
+require 'delegate'
+
+module Cequel
+
+  module Metal
+
+    class Writer
+
+      extend Forwardable
+
+      def initialize(data_set, options = {}, &block)
+        @data_set, @options, @block = data_set, options, block
+        @statements, @bind_vars = [], []
+        SimpleDelegator.new(self).instance_eval(&block) if block
+      end
+
+      def execute
+        return if empty?
+        statement = Statement.new
+        write_to_statement(statement)
+        statement.append(*data_set.row_specifications_cql)
+        data_set.write(*statement.args)
+      end
+
+      private
+      attr_reader :data_set, :options, :statements, :bind_vars
+      def_delegator :data_set, :table_name
+      def_delegator :statements, :empty?
+
+      def prepare_upsert_value(value)
+        case value
+        when ::Array
+          yield '[?]', value
+        when ::Set then
+          yield '{?}', value.to_a
+        when ::Hash then
+          binding_pairs = ::Array.new(value.length) { '?:?' }.join(',')
+          yield "{#{binding_pairs}}", *value.flatten
+        else
+          yield '?', value
+        end
+      end
+
+      #
+      # Generate CQL option statement for inserts and updates
+      #
+      # @param [Hash] options options for insert
+      # @option options [Symbol,String] :consistency required consistency for the write
+      # @option options [Integer] :ttl time-to-live in seconds for the written data
+      # @option options [Time,Integer] :timestamp the timestamp associated with the column values
+      #
+      def generate_upsert_options
+        if options.empty?
+          ''
+        else
+          ' USING ' <<
+          options.map do |key, value|
+            serialized_value =
+              case key
+              when :consistency then value.to_s.upcase
+              when :timestamp then (value.to_f * 1_000_000).to_i
+              else value
+              end
+            "#{key.to_s.upcase} #{serialized_value}"
+          end.join(' AND ')
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model.rb

@@ -1,100 +1,28 @@
 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/counter'
-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/schema'
 require 'cequel/model/properties'
-require 'cequel/model/remote_association'
-require 'cequel/model/scope'
+require 'cequel/model/collection'
+require 'cequel/model/persistence'
+require 'cequel/model/record_set'
 require 'cequel/model/scoped'
-require 'cequel/model/subclass_internals'
-require 'cequel/model/timestamps'
-require 'cequel/model/translation'
+require 'cequel/model/associations'
+require 'cequel/model/association_collection'
+require 'cequel/model/belongs_to_association'
+require 'cequel/model/has_many_association'
+require 'cequel/model/mass_assignment'
+require 'cequel/model/callbacks'
 require 'cequel/model/validations'
 
+require 'cequel/model/base'
+
 if defined? Rails
   require 'cequel/model/railtie'
 end
 
 module Cequel
-
-  #
-  # This module adds Cassandra persistence to a class using Cequel.
-  #
   module Model
-
-    @lock = Monitor.new
-
-    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
-      @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
-
-    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/association_collection.rb

@@ -0,0 +1,23 @@
+module Cequel
+
+  module Model
+
+    class AssociationCollection < DelegateClass(RecordSet)
+
+      include Enumerable
+
+      def each(&block)
+        target.each(&block)
+      end
+
+      private
+
+      def target
+        @target ||= __getobj__.entries
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/associations.rb

@@ -6,115 +6,119 @@ module Cequel
 
       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)
+      included do
+        class_attribute :parent_association
+        class_attribute :child_associations
+        self.child_associations = {}
+      end
 
-          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
+      module ClassMethods
 
-            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
+        include Forwardable
 
-            def #{association.foreign_key_name}=(key)
-              @_cequel.associations.delete(#{name.inspect})
-              write_attribute(#{association.foreign_key_name.inspect}, key)
-            end
-          RUBY
+        def belongs_to(name)
+          if parent_association
+            raise InvalidRecordConfiguration,
+              "Can't declare more than one belongs_to association"
+          end
+          if table_schema.key_columns.any?
+            raise InvalidRecordConfiguration,
+              "belongs_to association must be declared before declaring key(s)"
+          end
+          self.parent_association = BelongsToAssociation.new(self, name.to_sym)
+          parent_association.association_key_columns.each do |column|
+            key :"#{name}_#{column.name}", column.type
+          end
+          def_parent_association_accessors
         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
+        def has_many(name)
+          association = HasManyAssociation.new(self, name.to_sym)
+          self.child_associations =
+            child_associations.merge(name => association)
+          def_child_association_reader(association)
         end
 
-        def has_one(name, options = {})
-          name = name.to_sym
-          @_cequel.associations[name] =
-            RemoteAssociation.new(name, self, options.symbolize_keys)
+        private
 
-          module_eval <<-RUBY, __FILE__, __LINE__+1
-            def #{name}
-              self.class.reflect_on_association(#{name.inspect}).scope(self).first
-            end
-          RUBY
+        def def_parent_association_accessors
+          def_parent_association_reader
+          def_parent_association_writer
         end
 
-        def reflect_on_association(name)
-          @_cequel.association(name.to_sym)
+        def def_parent_association_reader
+          def_delegator 'self', :read_parent_association,
+            parent_association.name
         end
 
-        def reflect_on_associations
-          @_cequel.associations.values
+        def def_parent_association_writer
+          def_delegator 'self', :write_parent_association,
+            "#{parent_association.name}="
         end
 
-      end
-
-      def save(*args)
-        save_transient_associated
-        super
-      end
+        def def_child_association_reader(association)
+          module_eval <<-RUBY, __FILE__, __LINE__+1
+            def #{association.name}(reload = false)
+              read_child_association(#{association.name.inspect}, reload)
+            end
+          RUBY
+        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
+      def read_parent_association
+        ivar_name = parent_association.instance_variable_name
+        if instance_variable_defined?(ivar_name)
+          return instance_variable_get(ivar_name)
+        end
+        parent_key_values = key_values.
+          first(parent_association.association_key_columns.length)
+        if parent_key_values.none? { |value| value.nil? }
+          clazz = parent_association.association_class
+          parent = parent_key_values.inject(clazz) do |record_set, key_value|
+            record_set[key_value]
           end
+          instance_variable_set(ivar_name, parent)
         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
+      def write_parent_association(parent)
+        unless parent.is_a?(parent_association.association_class)
+          raise ArgumentError,
+            "Wrong class for #{parent_association.name}; expected " +
+            "#{parent_association.association_class.name}, got " +
+            "#{parent.class.name}"
+        end
+        instance_variable_set "@#{parent_association.name}", parent
+        key_column_names = self.class.key_column_names
+        parent.key_attributes.
+          zip(key_column_names) do |(parent_column_name, value), column_name|
+            if value.nil?
+              raise ArgumentError,
+                "Can't set parent association #{parent_association.name.inspect} " +
+                "without value in key #{parent_column_name.inspect}"
             end
+            write_attribute(column_name, value)
           end
+      end
+
+      def read_child_association(association_name, reload = false)
+        association = child_associations[association_name]
+        ivar = association.instance_variable_name
+        if !reload && instance_variable_defined?(ivar)
+          return instance_variable_get(ivar)
         end
+        association_record_set = key_values.inject(association.association_class) do |record_set, key_value|
+          record_set[key_value]
+        end
+        instance_variable_set(
+          ivar, AssociationCollection.new(association_record_set))
       end
 
     end
-    
+
   end
 
 end