massive_record 0.2.1 → 0.2.2.rc1

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

@@ -0,0 +1,17 @@
+require 'massive_record/orm/persistence/operations/table_operation_helpers'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        class Destroy
+          include Operations, TableOperationHelpers
+
+          def execute
+            row_for_record.destroy
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'massive_record/orm/persistence/operations/embedded/operation_helpers'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        module Embedded
+          class Destroy
+            include Operations, OperationHelpers
+
+            def execute
+              embedded_in_proxies.each do |proxy|
+                if proxy.load_proxy_target && proxy.load_proxy_target.persisted?
+                  inverse_proxy_for(proxy).delete(record)
+                  update_embedded(proxy, nil)
+                end
+              end
+
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'massive_record/orm/persistence/operations/embedded/operation_helpers'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        module Embedded
+          class Insert
+            include Operations, OperationHelpers
+
+            def execute
+              raise_error_if_embedded_in_proxy_targets_are_missing
+
+              # NOTE
+              #
+              # When / if we allow for auto-save false when assigning
+              # an embedded record to an embeds many collection we might
+              # want to only update current insert in the targets, not a
+              # complete save of the parent.
+              embedded_in_proxy_targets.collect(&:save).any?
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        module Embedded
+          module OperationHelpers
+            def embedded_in_proxies
+              record.relation_proxies.select { |proxy| proxy.metadata.embedded_in? }
+            end
+            
+            def embedded_in_proxy_targets
+              embedded_in_proxies.collect(&:load_proxy_target).compact
+            end
+
+            def raise_error_if_embedded_in_proxy_targets_are_missing
+              relations_not_assigned = []
+              relations_assigned = []
+
+              embedded_in_proxies.each do |proxy|
+                if proxy.load_proxy_target.nil? 
+                  relations_not_assigned << proxy.metadata.name
+                else
+                  relations_assigned << proxy.metadata.name
+                end
+              end
+
+              if relations_assigned.empty?
+                raise MassiveRecord::ORM::NotAssignedToEmbeddedCollection.new(record, relations_not_assigned)
+              end
+            end
+
+            def update_embedded(relation_proxy, value)
+              row = row_for_record(relation_proxy)
+              row.values = {
+                inverse_proxy_for(relation_proxy).metadata.store_in => {
+                  record.database_id => value
+                }
+              }
+              row.save
+            end
+
+
+
+
+
+
+            def inverse_proxy_for(proxy)
+              proxy.load_proxy_target.send(:relation_proxy, proxy.metadata.inverse_of)
+            end
+
+
+            def row_for_record(record)
+              raise IdMissing.new("You must set an ID before save.") if record.id.blank?
+
+              MassiveRecord::Wrapper::Row.new({
+                :id => record.id,
+                :table => record.class.table
+              })
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'massive_record/orm/persistence/operations/embedded/operation_helpers'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        module Embedded
+          class Reload
+            include Operations, OperationHelpers
+
+            class UnsupportedNumberOfEmbeddedIn < MassiveRecordError; end
+
+            def execute
+              if record.persisted? && embeds_many_proxy_to_reload_from
+                embeds_many_proxy_to_reload_from = inverse_proxy_for(embedded_in_proxies.first)
+                embeds_many_proxy_to_reload_from.reload
+                embeds_many_proxy_to_reload_from.find(record.id).tap do |reloaded_record|
+                  record.reinit_with({
+                    'attributes' => reloaded_record.attributes,
+                    'raw_data' => reloaded_record.raw_data
+                  })
+                end
+
+                true
+              end
+            end
+
+
+            private
+
+            def embeds_many_proxy_to_reload_from
+              @embeds_many_proxy_to_reload_from ||= embedded_in_proxies.select { |p| p.load_proxy_target.present? }.first
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'massive_record/orm/persistence/operations/embedded/operation_helpers'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        module Embedded
+          class Update
+            include Operations, OperationHelpers
+
+            def execute
+              raise_error_if_embedded_in_proxy_targets_are_missing
+              update_only_embedded_record_in_owners
+            end
+
+
+            private
+
+            def update_only_embedded_record_in_owners
+              embedded_in_proxies.select { |p| p.load_proxy_target.present? }.each do |proxy|
+                update_embedded(proxy, Base.coder.dump(record.attributes_db_raw_data_hash))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'massive_record/orm/persistence/operations/table_operation_helpers'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        class Insert
+          include Operations, TableOperationHelpers
+
+          def execute
+            ensure_that_we_have_table_and_column_families!
+            raise RecordNotUnique if klass.check_record_uniqueness_on_create && klass.exists?(record.id)
+            store_record_to_database('create')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'massive_record/orm/persistence/operations/table_operation_helpers'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        class Reload
+          include Operations, TableOperationHelpers
+
+          def execute
+            if record.persisted?
+              klass.find(record.id).tap do |reloaded_record|
+                record.reinit_with({
+                  'attributes' => reloaded_record.attributes,
+                  'raw_data' => reloaded_record.raw_data
+                })
+              end
+
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        class Suppress
+          include Operations
+
+          def execute
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require 'massive_record/orm/query_instrumentation'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        module TableOperationHelpers
+
+          def self.included(base)
+            base.class_eval do
+              include MassiveRecord::ORM::QueryInstrumentation::Operations
+            end
+          end
+
+
+          #
+          # Calculate which column families are missing in the database in
+          # context of what the schema instructs.
+          #
+          def self.calculate_missing_family_names(klass)
+            existing_family_names = klass.table.fetch_column_families.collect(&:name) rescue []
+            expected_family_names = klass.column_families ? klass.column_families.collect(&:name) : []
+
+            expected_family_names.collect(&:to_s) - existing_family_names.collect(&:to_s)
+          end
+
+          #
+          # Creates table for ORM classes
+          #
+          def self.hbase_create_table!(klass)
+            missing_family_names = calculate_missing_family_names(klass)
+            klass.table.create_column_families(missing_family_names) unless missing_family_names.empty?
+            klass.table.save
+          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 klass.table.exists?
+            raise ColumnFamiliesMissingError.new(klass, calculate_missing_family_names) if calculate_missing_family_names.any?
+          end
+
+          def hbase_create_table!
+            TableOperationHelpers.hbase_create_table!(klass)
+          end
+
+
+          def calculate_missing_family_names
+            TableOperationHelpers.calculate_missing_family_names(klass)
+          end
+
+
+
+
+
+          #
+          # Returns a Wrapper::Row class which we can manipulate this
+          # record in the database with
+          #
+          def row_for_record
+            raise IdMissing.new("You must set an ID before save.") if record.id.blank?
+
+            MassiveRecord::Wrapper::Row.new({
+              :id => record.id,
+              :table => klass.table
+            })
+          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 }
+
+            record.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(record[attr_name])
+            end
+
+            record.relation_proxies_for_embedded.select { |p| p.proxy_targets_update_hash.any? }.each do |proxy_with_changes|
+              values[proxy_with_changes.metadata.store_in].merge!(proxy_with_changes.proxy_targets_update_hash)
+            end
+
+            values
+          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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'massive_record/orm/persistence/operations/table_operation_helpers'
+
+module MassiveRecord
+  module ORM
+    module Persistence
+      module Operations
+        class Update
+          include Operations, TableOperationHelpers
+
+          def execute
+            ensure_that_we_have_table_and_column_families!
+            store_record_to_database('update', attribute_names_to_update)
+          end
+
+
+          private
+
+          def attribute_names_to_update
+            options[:attribute_names_to_update] || []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/query_instrumentation.rb

@@ -1,64 +1,41 @@
 module MassiveRecord
   module ORM
     module QueryInstrumentation
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        #
-        # do_find is the method which *all* find operations goes
-        # through. For instrumentation on the query only see
-        # hbase_query_all_first /hbase_query_find
-        #
-        def do_find(*args)
-          ActiveSupport::Notifications.instrument("load.massive_record", {
-            :name => [model_name, 'load'].join(' '),
-            :description => "",
-            :options => args
-          }) do
-            super
+      module Table
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          %w(find_one find_some find_all).each do |method_to_instrument|
+            module_eval <<-RUBY, __FILE__, __LINE__
+
+              def #{method_to_instrument}(*args)
+                ActiveSupport::Notifications.instrument("load.massive_record", {
+                  :name => [model_name, 'load'].join(' '),
+                  :description => "#{method_to_instrument}",
+                  :options => args
+                }) do
+                  super
+                end
+              end
+
+            RUBY
           end
         end
+      end
 
+      module Operations
+        def store_record_to_database(action, attribute_names_to_update = [])
+          description = action + " id: #{record.id},"
+          description += " attributes: #{attribute_names_to_update.join(', ')}" if attribute_names_to_update.any?
 
-
-
-        private
-
-        def hbase_query_all_first(type, *args)
-          ActiveSupport::Notifications.instrument("find_query.massive_record", {
-            :name => [model_name, 'query'].join(' '),
-            :description => type,
-            :options => args
-          }) do
-            super
-          end
-        end
-
-        def hbase_query_find(what_to_find, options)
-          ActiveSupport::Notifications.instrument("find_query.massive_record", {
-            :name => [model_name, 'query'].join(' '),
-            :description => "find id(s): #{what_to_find}",
-            :options => options
+          ActiveSupport::Notifications.instrument("query.massive_record", {
+            :name => [klass.model_name, 'save'].join(' '),
+            :description => description
           }) do
             super
           end
         end
       end
-
-
-      private
-
-      def store_record_to_database(action, attribute_names_to_update = [])
-        description = action + " id: #{id},"
-        description += " attributes: #{attribute_names_to_update.join(', ')}" if attribute_names_to_update.any?
-
-        ActiveSupport::Notifications.instrument("query.massive_record", {
-          :name => [self.class.model_name, 'save'].join(' '),
-          :description => description
-        }) do
-          super
-        end
-      end
     end
   end
 end