massive_record 0.2.1 → 0.2.2.rc1

data/lib/massive_record/orm/relations/proxy/embedded_in_polymorphic.rb

@@ -0,0 +1,15 @@
+module MassiveRecord
+  module ORM
+    module Relations
+      class Proxy
+        class EmbeddedInPolymorphic < EmbeddedIn
+          private
+
+          # Skip check on polymorphic relation
+          def raise_if_type_mismatch(record)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/relations/proxy/embeds_many.rb

@@ -0,0 +1,215 @@
+module MassiveRecord
+  module ORM
+    module Relations
+      class Proxy
+        class EmbedsMany < ProxyCollection
+          def find(id)
+            record =  if loaded? || proxy_owner.new_record?
+                        proxy_target.detect { |record| record.id == id }
+                      else
+                        find_one_embedded_record_from_raw_data(id)
+                      end
+
+            record or raise RecordNotFound.new("Could not find #{proxy_target_class.model_name} with id=#{id}")
+          end
+
+          def limit(limit)
+            load_proxy_target.slice(0, limit)
+          end
+
+
+          #
+          # Adding record(s) to the collection.
+          #
+          def <<(*records)
+            records.flatten.each do |record|
+              unless include? record
+                raise_if_type_mismatch(record)
+                proxy_target << record
+                record.send(metadata.inverse_of).replace(proxy_owner, false)
+              end
+            end
+
+            if proxy_owner.persisted?
+              proxy_owner.save
+            else
+              proxy_target.sort_by! &:id
+            end
+
+            self
+          end
+          alias_method :push, :<<
+          alias_method :concat, :<<
+
+
+          #
+          # Checks if record is included in collection
+          #
+          def include?(record)
+            load_proxy_target.include? record
+          end
+
+          def length
+            load_proxy_target.length
+          end
+          alias_method :count, :length
+          alias_method :size, :length
+
+
+
+
+
+          #
+          # Returns the raw hash of attributes for embedded objects
+          # It filters away database_ids (keys in a column family)
+          # which it does not recognize.
+          #
+          def proxy_targets_raw # :nodoc:
+            Hash[proxy_owner.raw_data[metadata.store_in].collect do |database_id, value|
+              begin
+                base_class, id = Embedded.parse_database_id(database_id)
+                [id, value] if base_class == proxy_target_class.base_class.to_s.underscore
+              rescue InvalidEmbeddedDatabaseId
+              end
+            end.compact]
+          end
+
+
+
+
+          #
+          # Hook which are called just before save.
+          # It iterates over new or changed records, asking them to "save" themself.
+          # This will result in created_at / updated_at and persistence state being set.
+          # It will also build the proxy_targets_update_hash with these
+          # changes, which will be used at the proxy owner's save for actually updating
+          # these records.
+          #
+          def parent_will_be_saved! # :nodoc:
+            proxy_targets_update_hash.clear
+
+            MassiveRecord::ORM::Persistence::Operations.suppress do
+              proxy_target.each do |record|
+                if record.destroyed?
+                  proxy_targets_update_hash[record.database_id] = nil
+                elsif record.new_record? || record.changed?
+                  record.save 
+                  proxy_targets_update_hash[record.database_id] = Base.coder.dump(record.attributes_db_raw_data_hash)
+                end
+              end
+
+              to_be_destroyed.each do |record|
+                targets_current_owner = record.send(metadata.inverse_of).proxy_target
+                if targets_current_owner.nil? || targets_current_owner == proxy_owner
+                  record.destroy
+                  proxy_targets_update_hash[record.database_id] = nil
+                end
+              end
+              to_be_destroyed.clear
+            end
+          end
+
+          # Hook to call when save is done through parent
+          def parent_has_been_saved!
+            reload_raw_data
+            proxy_targets_update_hash.clear
+          end
+
+          def proxy_targets_update_hash
+            @proxy_targets_update_hash ||= {}
+          end
+
+
+
+
+
+
+
+
+          def changed?
+            to_be_destroyed.any? || proxy_target.any? do |record|
+                                      record.new_record? || record.destroyed? || record.changed?
+                                    end
+          end
+
+          def changes
+            Hash[proxy_target.collect do |record|
+              if record.changed?
+                [record.id, record.changes]
+              end
+            end.compact]
+          end
+
+
+
+
+          private
+
+          def find_proxy_target(options = {})
+            reload_raw_data if proxy_targets_raw.empty?
+
+            proxy_targets_raw.inject([]) do |records, (id, raw_data)|
+              records << instantiate_target_class(id, raw_data)
+            end
+          end
+
+          #
+          # Replaces the raw_data hash in parent with reloaded data from database
+          #
+          def reload_raw_data
+            if proxy_owner.persisted?
+              reloaded_data = proxy_owner.class.select(metadata.store_in).find(proxy_owner.id).raw_data[metadata.store_in]
+              proxy_owner.update_raw_data_for_column_family(metadata.store_in, reloaded_data)
+            end
+          rescue MassiveRecord::ORM::RecordNotFound
+            # When we try to load raw data we might end up getting nil back, even though
+            # a row exists with given id. The reason for this is that when only selecting
+            # one column family (family for embedded records) and that family is empty for
+            # a given row we'll end up getting nil back, resulting in a record not found error.
+          end
+
+
+          def find_one_embedded_record_from_raw_data(id)
+            raw_data = proxy_targets_raw[id] || load_raw_data_for_id(id)
+            instantiate_target_class(id, raw_data) if raw_data
+          end
+
+          def load_raw_data_for_id(id)
+            database_id = Embedded.database_id(proxy_target_class, id)
+            if cell = proxy_owner.class.table.get_cell(proxy_owner.id, metadata.store_in, database_id)
+              RawData.new_with_data_from cell
+            end
+          end
+
+          # FIXME Common to all proxies representing multiple values
+          def find_proxy_target_with_proc(options = {}, &block)
+            Array(super).compact
+          end
+
+          def delete_or_destroy(*records, method)
+            records.flatten!
+            self.proxy_target -= records
+            to_be_destroyed.concat(records).uniq!
+            proxy_owner.save if proxy_owner.persisted? && method == :destroy
+            records
+          end
+
+          def can_find_proxy_target?
+            true
+          end
+
+
+          def to_be_destroyed
+            @to_be_destroyed ||= []
+          end
+
+          def instantiate_target_class(id, raw_data)
+            proxy_target_class.send(:instantiate, *proxy_target_class.transpose_raw_data_to_record_attributes_and_raw_data(id, raw_data)).tap do |record|
+              record.send(metadata.inverse_of).replace(proxy_owner, false)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/relations/proxy/references_many.rb

@@ -2,41 +2,21 @@ module MassiveRecord
   module ORM
     module Relations
       class Proxy
-        class ReferencesMany < Proxy
-          #
-          # Loading proxy_targets will merge it with records found currently in proxy,
-          # to make sure we don't remove any pushed proxy_targets only cause we load the
-          # proxy_targets.
-          #
-          # TODO  - Implement methods like:
-          #         * find_in_batches
-          #         * find_each
-          #         * etc :-)
+        class ReferencesMany < ProxyCollection
+
           #
-          #       - A counter cache is also nice.
+          # Raised when we are in a references many relationship where the
+          # target's foreign keys are persisted in the owner and you try to
+          # do a person.cars.all(:limit => 1, :offset => "something") and
+          # some of these options are unsupported. The reason for these being
+          # unsupported is that we have to implement offset and limitiation
+          # in pure Ruby working on that car_ids array in the person. Its
+          # nothing close to impossible; it just has not been done yet.
           #
-          def load_proxy_target
-            proxy_target_before_load = proxy_target
-            proxy_target_after_load = super
-
-            self.proxy_target = (proxy_target_before_load + proxy_target_after_load).uniq
+          class UnsupportedFinderOption < MassiveRecordError
+            OPTIONS = %w(limit offset starts_with)
           end
 
-          def reset
-            super
-            @proxy_target = []
-          end
-
-          def replace(*records)
-            records.flatten!
-
-            if records.length == 1 and records.first.nil?
-              reset
-            else
-              delete_all
-              concat(records)
-            end
-          end
 
 
           #
@@ -63,74 +43,49 @@ module MassiveRecord
           alias_method :push, :<<
           alias_method :concat, :<<
 
-          #
-          # Destroy record(s) from the collection
-          # Each record will be asked to destroy itself as well
-          #
-          def destroy(*records)
-            delete_or_destroy *records, :destroy
-          end
-
-          #
-          # Deletes record(s) from the collection
-          #
-          def delete(*records)
-            delete_or_destroy *records, :delete
-          end
-
-          #
-          # Destroys all records
-          #
-          def destroy_all
-            destroy(load_proxy_target)
-            reset
-            loaded!
-          end
-
-          #
-          # Deletes all records from the relationship.
-          # Does not destroy the records
-          #
-          def delete_all
-            delete(load_proxy_target)
-            reset
-            loaded!
-          end
 
           #
           # Checks if record is included in collection
           #
-          # TODO  This needs a bit of work, depending on if proxy's proxy_target
-          #       has been loaded or not. For now, we are just checking
-          #       what we currently have in @proxy_target
-          #
-          def include?(record)
-            load_proxy_target.include? record
+          def include?(record_or_id)
+            id = record_or_id.respond_to?(:id) ? record_or_id.id : record_or_id
+
+            if loaded? || find_with_proc?
+              !!find(id)
+            else
+              foreign_key_in_proxy_owner_exists? id
+            end
+          rescue RecordNotFound
+            false
           end
 
           #
           # Returns the length of targes
           #
-          # TODO  This can be smarter as well. For instance; if we have not
-          #       loaded targets, and we have foreign keys in the owner we
-          #       can simply do a owner's foreign keys and ask for it's length.
-          #
           def length
-            load_proxy_target.length
+            if loaded?
+              proxy_target.length
+            elsif find_with_proc?
+              load_proxy_target.length
+            else
+              foreign_keys_in_proxy_owner.length
+            end
           end
           alias_method :count, :length
           alias_method :size, :length
 
-          def empty?
-            length == 0
+          def any?
+            if !loaded? && find_with_proc?
+              !!first
+            else
+              !empty?
+            end
           end
+          alias_method :present?, :any?
 
-          def first
-            limit(1).first
-          end
 
           def find(id)
-            if loaded?
+            if loaded? || proxy_owner.new_record?
               record = proxy_target.find { |record| record.id == id }
             elsif find_with_proc?
               if id.starts_with? proxy_owner.send(metadata.records_starts_from)
@@ -145,6 +100,53 @@ module MassiveRecord
             record
           end
 
+          def all(options = {})
+            options = MassiveRecord::Adapters::Thrift::Table.warn_and_change_deprecated_finder_options(options)
+
+            load_proxy_target(options)
+          end
+
+          #
+          # Find records in batches, yields batch into your block
+          #
+          # Options:
+          #   <tt>:batch_size</tt>    The number of records you want per batch. Defaults to 1000
+          #   <tt>:starts_with</tt>         The ids starts with this
+          #
+          def find_in_batches(options = {}, &block)
+            options = MassiveRecord::Adapters::Thrift::Table.warn_and_change_deprecated_finder_options(options)
+
+            options[:batch_size] ||= 1000
+
+            if loaded?
+              collection =  if options[:starts_with]
+                              proxy_target.select { |r| r.id.starts_with? options[:starts_with] }
+                            else
+                              proxy_target
+                            end
+              collection.in_groups_of(options[:batch_size], false, &block)
+            elsif find_with_proc?
+              find_proxy_target_with_proc(options.merge(:finder_method => :find_in_batches), &block)
+            else
+              all_ids = proxy_owner.send(metadata.foreign_key)
+              all_ids = all_ids.select { |id| id.starts_with? options[:starts_with] } if options[:starts_with]
+              all_ids.in_groups_of(options[:batch_size]).each do |ids_in_batch|
+                yield Array(find_proxy_target(:ids => ids_in_batch))
+              end
+            end
+          end
+
+          #
+          # Fetches records in batches of 1000 (by default), iterates over each batch
+          # and yields one and one record in to given block. See find_in_batches for
+          # options.
+          #
+          def find_each(options = {})
+            find_in_batches(options) do |batch|
+              batch.each { |record| yield record }
+            end
+          end
+
           #
           # Returns a limited result set of target records.
           #
@@ -153,25 +155,31 @@ module MassiveRecord
           #       than foreign keys length.
           #
           def limit(limit)
-            if loaded?
+            if loaded? || proxy_owner.new_record?
               proxy_target.slice(0, limit)
             elsif find_with_proc?
               find_proxy_target_with_proc(:limit => limit)
             else
               ids = proxy_owner.send(metadata.foreign_key).slice(0, limit)
               ids = ids.first if ids.length == 1
-              [find_proxy_target(ids)].flatten
+              Array(find_proxy_target(:ids => ids))
             end
           end
 
 
+          def is_a?(klass)
+            klass == Array
+          end
 
           private
 
 
           def delete_or_destroy(*records, method)
+            removed = []
+
             records.flatten.each do |record|
               if include? record
+                removed << record
                 remove_foreign_key_in_proxy_owner(record.id)
                 proxy_target.delete(record)
                 record.destroy if method.to_sym == :destroy
@@ -179,17 +187,29 @@ module MassiveRecord
             end
 
             proxy_owner.save if proxy_owner.persisted?
+            removed
           end
 
 
 
-          def find_proxy_target(ids = nil)
-            ids = proxy_owner.send(metadata.foreign_key) if ids.nil?
+          def find_proxy_target(options = {})
+            ids = options.delete(:ids) || proxy_owner.send(metadata.foreign_key)
+            unsupported_finder_options = UnsupportedFinderOption::OPTIONS & options.keys.collect(&:to_s)
+
+            if unsupported_finder_options.any?
+              raise UnsupportedFinderOption.new(
+                <<-TXT
+                  Sorry, option(s): #{unsupported_finder_options.join(', ')} are not supported when foreign
+                  keys are persisted in proxy owner #{proxy_owner.class}
+                TXT
+              )
+            end
+
             proxy_target_class.find(ids, :skip_expected_result_check => true)
           end
 
-          def find_proxy_target_with_proc(options = {})
-            [super].compact.flatten
+          def find_proxy_target_with_proc(options = {}, &block)
+            Array(super).compact
           end
 
           def can_find_proxy_target?
@@ -215,7 +235,11 @@ module MassiveRecord
           end
 
           def foreign_key_in_proxy_owner_exists?(id)
-            proxy_owner.send(metadata.foreign_key).include? id
+            foreign_keys_in_proxy_owner.include? id
+          end
+
+          def foreign_keys_in_proxy_owner
+            proxy_owner.send(metadata.foreign_key)
           end
 
           def notify_of_change_in_proxy_owner_foreign_key