massive_record 0.2.1 → 0.2.2.rc1

data/lib/massive_record/orm/log_subscriber.rb

@@ -42,6 +42,24 @@ module MassiveRecord
         debug "  " + [name, description, options].compact.join("  ")
       end
 
+      def identity_map(event)
+        return unless logger.debug?
+
+        payload = event.payload
+        name = '%s (%.1fms)' % [payload[:name], event.duration]
+        records = payload[:records]
+        ids = "id(s): #{records.collect(&:id)}"
+
+        if odd?
+          name = color(name, CYAN, true)
+          description = color(description, nil, true)
+        else
+          name = color(name, MAGENTA, true)
+        end
+
+        debug "    " + [name, ids].compact.join("  ")
+      end
+
       def query(event)
         return unless logger.debug?
 

data/lib/massive_record/orm/observer.rb

@@ -0,0 +1,69 @@
+module MassiveRecord
+  module ORM
+
+    #
+    # MassiveRecord Observer. Greatly influenced by ActiveRecord's
+    # way of doing callbacks, thus should feel familiar to most people.
+    #
+    # NOTE  that if you are using rails you should add observers to into
+    #       your application.rb configuration file like this:
+    #
+    #       config.massive_record.observers = :person_observer, :audit_observer
+    #
+    #       This will ensure that observers are loaded correctly. If you are not
+    #       using rails you can do: MassiveRecord::ORM::Base.instantiate_observers
+    #       after your application has been initialized.
+    #
+    # Example of usage:
+    #
+    # class Person < MassiveRecord::ORM::Table
+    #   column_family :info do
+    #     field :name
+    #   end
+    # end
+    #
+    # class PersonObserver < MassiveRecord::ORM::Observer
+    #   def after_save(saved_person_record)
+    #     # do something here after people are being saved
+    #   end
+    # end
+    #
+    # class AuditObserver < MassiveRecord::ORM::Observer
+    #   observe :person, :and, :other, :classes
+    #
+    #   def after_save(saved_person_record)
+    #     # do something here after people are being saved
+    #   end
+    # end
+    #
+    class Observer < ActiveModel::Observer
+      protected
+
+      def observed_classes
+        klasses = super
+        klasses + klasses.map { |klass| klass.descendants }.flatten
+      end
+
+      def add_observer!(klass)
+        super
+        define_callbacks klass
+      end
+
+      def define_callbacks(klass)
+        observer = self
+        observer_name = observer.class.name.underscore.gsub('/', '__')
+
+        MassiveRecord::ORM::Callbacks::CALLBACKS.each do |callback|
+          next unless respond_to?(callback)
+          callback_meth = :"_notify_#{observer_name}_for_#{callback}"
+          unless klass.respond_to?(callback_meth)
+            klass.send(:define_method, callback_meth) do |&block|
+              observer.send(callback, self, &block)
+            end
+            klass.send(callback, callback_meth)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/persistence.rb

@@ -1,3 +1,5 @@
+require 'massive_record/orm/persistence/operations'
+
 module MassiveRecord
   module ORM
     module Persistence
@@ -14,42 +16,6 @@ module MassiveRecord
         def destroy_all
           all.each { |record| record.destroy }
         end
-        
-
-        #
-        # Iterates over tables and column families and ensure that we
-        # have what we need
-        #
-        def ensure_that_we_have_table_and_column_families! # :nodoc:
-          # 
-          # TODO: Can we skip checking if it exists at all, and instead, rescue it if it does not?
-          #
-          hbase_create_table! unless table.exists?
-          raise ColumnFamiliesMissingError.new(self, calculate_missing_family_names) if calculate_missing_family_names.any?
-        end
-
-
-        private
-
-        #
-        # Creates table for this ORM class
-        #
-        def hbase_create_table!
-          missing_family_names = calculate_missing_family_names
-          table.create_column_families(missing_family_names) unless missing_family_names.empty?
-          table.save
-        end
-
-        #
-        # Calculate which column families are missing in the database in
-        # context of what the schema instructs.
-        #
-        def calculate_missing_family_names
-          existing_family_names = table.fetch_column_families.collect(&:name) rescue []
-          expected_family_names = column_families ? column_families.collect(&:name) : []
-
-          expected_family_names.collect(&:to_s) - existing_family_names.collect(&:to_s)
-        end
       end
 
 
@@ -67,7 +33,7 @@ module MassiveRecord
 
 
       def reload
-        self.attributes_raw = self.class.find(id).attributes if persisted?
+        Operations.reload(self).execute
         self
       end
       
@@ -101,11 +67,31 @@ module MassiveRecord
       end
 
       def destroy
-        @destroyed = (persisted? ? row_for_record.destroy : true) and freeze
+        @destroyed = (persisted? ? do_destroy : true) and freeze
       end
       alias_method :delete, :destroy
 
 
+      def change_id!(new_id)
+        old_id, self.id = id, new_id
+
+        @new_record = true
+        unless save
+          raise <<-TXT
+            Unable to save #{self.class} with updated id '#{new_id}'.
+            Old id '#{old_id}' was not deleted so in theory nothing should be changed in the database.
+          TXT
+        end
+
+        unless self.class.find(old_id).destroy
+          raise <<-TXT
+            Unable to destroy #{self.class} with id '#{old_id}'.
+            You now how duplicate records in the database. New id is: '#{new_id}.'
+          TXT
+        end
+
+        reload
+      end
 
 
       def increment(attr_name, by = 1)
@@ -119,21 +105,11 @@ module MassiveRecord
         increment(attr_name, by).update_attribute(attr_name, self[attr_name])
       end
 
-      # Atomic increment of an attribute. Please note that it's the
-      # adapter (or the wrapper) which needs to guarantee that the update
-      # is atomic, and as of writing this the Thrift adapter / wrapper does
-      # not do this anatomic.
       def atomic_increment!(attr_name, by = 1)
-        self.class.ensure_that_we_have_table_and_column_families!
-        attr_name = attr_name.to_s
-
-        ensure_proper_binary_integer_representation(attr_name)
-
-        self[attr_name] = row_for_record.atomic_increment(attributes_schema[attr_name].unique_name, by)
-        @new_record = false
-        self[attr_name]
+        atomic_operation(:increment, attr_name, by)
       end
 
+
       def decrement(attr_name, by = 1)
         raise NotNumericalFieldError unless attributes_schema[attr_name.to_s].type == :integer
         self[attr_name] ||= 0
@@ -144,6 +120,11 @@ module MassiveRecord
       def decrement!(attr_name, by = 1)
         decrement(attr_name, by).update_attribute(attr_name, self[attr_name])
       end
+
+      def atomic_decrement!(attr_name, by = 1)
+        atomic_operation(:decrement, attr_name, by)
+      end
+
       
 
       private
@@ -151,94 +132,41 @@ module MassiveRecord
 
       def create_or_update
         raise ReadOnlyRecord if readonly?
+
         !!(new_record? ? create : update)
       end
 
       def create
-        self.class.ensure_that_we_have_table_and_column_families!
-
-        raise RecordNotUnique if check_record_uniqueness_on_create && self.class.exists?(id)
-
-        if saved = store_record_to_database('create')
-          @new_record = false
+        Operations.insert(self).execute.tap do |saved|
+          @new_record = false if saved
         end
-        saved
       end
 
-      def update(attribute_names_to_update = attributes.keys)
-        self.class.ensure_that_we_have_table_and_column_families!
-
-        store_record_to_database('update', attribute_names_to_update)
+      def update(attribute_names_to_update = attributes_with_embedded)
+        Operations.update(self, :attribute_names_to_update => attribute_names_to_update).execute
       end
 
-
-
-
-      #
-      # Takes care of the actual storing of the record to the database
-      # Both update and create is using this
-      #
-      def store_record_to_database(action, attribute_names_to_update = [])
-        row = row_for_record
-        row.values = attributes_to_row_values_hash(attribute_names_to_update)
-        row.save
+      def do_destroy
+        Operations.destroy(self).execute
       end
 
-
-
       #
-      # Returns a Wrapper::Row class which we can manipulate this
-      # record in the database with
+      # Atomic decrement of an attribute. Please note that it's the
+      # adapter (or the wrapper) which needs to guarantee that the update
+      # is atomic. Thrift adapter is working with atomic decrementation.
       #
-      def row_for_record
-        raise IdMissing.new("You must set an ID before save.") if id.blank?
-
-        MassiveRecord::Wrapper::Row.new({
-          :id => id,
-          :table => self.class.table
-        })
+      def atomic_operation(operation, attr_name, by)
+        Operations.atomic_operation(self, :operation => operation, :attr_name => attr_name, :by => by).execute
       end
 
-      #
-      # Returns attributes on a form which Wrapper::Row expects
-      #
-      def attributes_to_row_values_hash(only_attr_names = [])
-        values = Hash.new { |hash, key| hash[key] = Hash.new }
-
-        attributes_schema.each do |attr_name, orm_field|
-          next unless only_attr_names.empty? || only_attr_names.include?(attr_name)
-          values[orm_field.column_family.name][orm_field.column] = orm_field.encode(self[attr_name])
-        end
 
-        values
-      end
 
       #
-      # To cope with the problem which arises when you ask to
-      # do atomic incrementation of an attribute and that attribute
-      # has a string representation of a number, like "1", instead of
-      # the binary representation, like "\x00\x00\x00\x00\x00\x00\x00\x01".
+      # Gives you all attribute names pluss all known embedded
+      # attributes names. Is used if dirty is active.
       #
-      # We then need to re-write that string representation into
-      # hex representation. Now, if you are on a completely new
-      # database and have never used MassiveRecord before we should not
-      # need to do this at all; numbers are now stored as hex, but for
-      # backward compatibility we are doing this.
-      #
-      # Now, there is a risk of doing this; if two calls are made to
-      # atomic_increment! on a record where it's value is a string
-      # representation this operation might be compromised. Therefor
-      # you need to enable this feature.
-      #
-      def ensure_proper_binary_integer_representation(attr_name)
-        return if !backward_compatibility_integers_might_be_persisted_as_strings || new_record?
-
-        field = attributes_schema[attr_name]  
-        raise "Not an integer field" unless field.try(:type) == :integer
-
-        if raw_value = self.class.table.get(id, field.column_family.name, field.name)
-          store_record_to_database('update', [attr_name]) if raw_value =~ /\A\d*\Z/
-        end
+      def attributes_with_embedded
+        attributes.keys | relation_proxies_for_embedded.collect { |proxy| proxy.metadata.name }
       end
     end
   end

data/lib/massive_record/orm/persistence/operations.rb

@@ -0,0 +1,100 @@
+require 'massive_record/orm/persistence/operations/suppress'
+
+require 'massive_record/orm/persistence/operations/insert'
+require 'massive_record/orm/persistence/operations/update'
+require 'massive_record/orm/persistence/operations/destroy'
+require 'massive_record/orm/persistence/operations/reload'
+require 'massive_record/orm/persistence/operations/atomic_operation'
+
+require 'massive_record/orm/persistence/operations/embedded/insert'
+require 'massive_record/orm/persistence/operations/embedded/update'
+require 'massive_record/orm/persistence/operations/embedded/destroy'
+require 'massive_record/orm/persistence/operations/embedded/reload'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+
+      #
+      # The persistence Operations are in charge of inserting,
+      # updating and destroying records.
+      #
+      # It's reason for even existing is that we need to
+      # do these operations differently based on if we are
+      # saving a record which has a Table as it's class or saving
+      # an embedded record.
+      #
+      # The Persistence module will call upon
+      # Operations.insert(record, options) and execute on the returned
+      # object. Based on what kind of record we are getting in we
+      # can determine what kind of Operation object to return
+      #
+      module Operations
+        class << self
+          def suppress
+            @suppressed = true
+            yield
+          ensure
+            @suppressed = false
+          end
+
+          def suppressed?
+            !!@suppressed
+          end
+
+
+          def insert(record, options = {})
+            operator_for :insert, record, options
+          end
+
+          def update(record, options = {})
+            operator_for :update, record, options
+          end
+
+          def destroy(record, options = {})
+            operator_for :destroy, record, options
+          end
+
+          def atomic_operation(record, options = {})
+            operator_for :atomic_operation, record, options
+          end
+
+          def reload(record, options = {})
+            operator_for :reload, record, options
+          end
+
+          private
+          
+          def operator_for(operation, record, options)
+            if suppressed?
+              klass = Suppress
+            else
+              class_parts = [self]
+              class_parts << "Embedded" if record.kind_of? ORM::Embedded
+              class_parts << operation.to_s.classify
+
+              klass = class_parts.join("::").constantize
+            end
+
+            klass.new(record, options)
+          end
+        end
+
+
+        attr_reader :record, :klass, :options
+
+
+        def initialize(record, options = {})
+          @record = record
+          @klass = record.class
+          @options = options
+        end
+
+
+        def execute
+          raise "Not implemented"
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/persistence/operations/atomic_operation.rb

@@ -0,0 +1,71 @@
+require 'massive_record/orm/persistence/operations/table_operation_helpers'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        class AtomicOperation
+          include Operations, TableOperationHelpers
+
+          def execute
+            raise NotNumericalFieldError unless record.attributes_schema[attr_name].type == :integer
+
+            ensure_that_we_have_table_and_column_families!
+            ensure_proper_binary_integer_representation(attr_name)
+            record[attr_name] = row_for_record.send("atomic_#{operation}", record.attributes_schema[attr_name].unique_name, by)
+          ensure
+            record.instance_variable_set(:@new_record, false)
+          end
+
+
+          private
+
+          #
+          # To cope with the problem which arises when you ask to
+          # do atomic incrementation / decrementation of an attribute and that attribute
+          # has a string representation of a number, like "1", instead of
+          # the binary representation, like "\x00\x00\x00\x00\x00\x00\x00\x01".
+          #
+          # We then need to re-write that string representation into
+          # hex representation. Now, if you are on a completely new
+          # database and have never used MassiveRecord before we should not
+          # need to do this at all; numbers are now stored as hex, but for
+          # backward compatibility we are doing this.
+          #
+          # Now, there is a risk of doing this; if two calls are made to
+          # atomic_increment! or atomic_decrement! on a record where it's value is a string
+          # representation this operation might be compromised. Therefor
+          # you need to enable this feature.
+          #
+          def ensure_proper_binary_integer_representation(attr_name)
+            return if !klass.backward_compatibility_integers_might_be_persisted_as_strings || record.new_record?
+
+            field = record.attributes_schema[attr_name]
+
+            if raw_value = klass.table.get(record.id, field.column_family.name, field.name)
+              store_record_to_database('update', [attr_name]) if raw_value =~ /\A\d*\Z/
+            end
+          end
+
+
+          def operation
+            options[:operation] or raise "Missing option :operation"
+          end
+
+          def attr_name
+            @attr_name ||= if options[:attr_name].present?
+                             options[:attr_name].to_s
+                           else
+                             raise "Missing option :attr_name"
+                           end
+          end
+
+          def by
+            options[:by] or raise "Missing option :by"
+          end
+        end
+      end
+    end
+  end
+end
+