inventory_refresh 0.2.2 → 0.3.0

data/lib/inventory_refresh/inventory_object_lazy.rb

@@ -30,7 +30,6 @@ module InventoryRefresh
 
     # @return [String] stringified reference
     def to_s
-      # TODO(lsmola) do we need this method?
       stringified_reference
     end
 
@@ -71,10 +70,6 @@ module InventoryRefresh
 
     # @return [Boolean] true if the key is an association on inventory_collection_scope model class
     def association?(key)
-      # TODO(lsmola) remove this if there will be better dependency scan, probably with transitive dependencies filled
-      # in a second pass, then we can get rid of this hardcoded symbols. Right now we are not able to introspect these.
-      return true if [:parent, :genealogy_parent].include?(key)
-
       inventory_collection.dependency_attributes.key?(key) ||
         !inventory_collection.association_to_foreign_key_mapping[key].nil?
     end
@@ -100,7 +95,7 @@ module InventoryRefresh
 
     private
 
-    delegate :parallel_safe?, :saved?, :saver_strategy, :skeletal_primary_index, :targeted?, :to => :inventory_collection
+    delegate :saved?, :saver_strategy, :skeletal_primary_index, :to => :inventory_collection
     delegate :nested_secondary_index?, :primary?, :full_reference, :keys, :primary?, :to => :reference
 
     attr_writer :reference
@@ -112,20 +107,18 @@ module InventoryRefresh
     #
     # @return [InventoryRefresh::InventoryObject, NilClass] Returns pre-created InventoryObject or nil
     def skeletal_precreate!
-      # We can do skeletal pre-create only for strategies using unique indexes. Since this can build records out of
-      # the given :arel scope, we will always attempt to create the recod, so we need unique index to avoid duplication
-      # of records.
-      return unless parallel_safe?
       # Pre-create only for strategies that will be persisting data, i.e. are not saved already
       return if saved?
       # We can only do skeletal pre-create for primary index reference, since that is needed to create DB unique index
-      return unless primary?
-      # Full reference must be present
-      return if full_reference.blank?
-
-      # To avoid pre-creating invalid records all fields of a primary key must have value
-      # TODO(lsmola) for composite keys, it's still valid to have one of the keys nil, figure out how to allow this
-      return if keys.any? { |x| full_reference[x].blank? }
+      # and full reference must be present
+      return if !primary? || full_reference.blank?
+
+      # To avoid pre-creating invalid records all fields of a primary key must have non null value
+      # TODO(lsmola) for composite keys, it's still valid to have one of the keys nil, figure out how to allow this. We
+      # will need to scan the DB for NOT NULL constraint and allow it based on that. So we would move this check to
+      # saving code, but this will require bigger change, since having the column nil means we will have to batch it
+      # smartly, since having nil means we will need to use different unique index for the upsert/update query.
+      return if keys.any? { |x| full_reference[x].nil? }
 
       skeletal_primary_index.build(full_reference)
     end

data/lib/inventory_refresh/persister.rb

@@ -3,15 +3,13 @@ module InventoryRefresh
     require 'json'
     require 'yaml'
 
-    attr_reader :manager, :target, :collections
+    attr_reader :manager, :collections
 
     attr_accessor :refresh_state_uuid, :refresh_state_part_uuid, :total_parts, :sweep_scope, :retry_count, :retry_max
 
     # @param manager [ManageIQ::Providers::BaseManager] A manager object
-    # @param target [Object] A refresh Target object
-    def initialize(manager, target = nil)
+    def initialize(manager)
       @manager = manager
-      @target  = target
 
       @collections = {}
 
@@ -45,9 +43,6 @@ module InventoryRefresh
                                            &block)
 
       builder.add_properties(extra_properties) if extra_properties.present?
-
-      builder.add_properties({:manager_uuids => target.try(:references, collection_name) || []}, :if_missing) if targeted?
-
       builder.evaluate_lambdas!(self)
 
       collections[collection_name] = builder.to_inventory_collection
@@ -104,8 +99,6 @@ module InventoryRefresh
     def to_hash
       collections_data = collections.map do |_, collection|
         next if collection.data.blank? &&
-                collection.targeted_scope.primary_references.blank? &&
-                collection.all_manager_uuids.nil? &&
                 collection.skeletal_primary_index.index_data.blank?
 
         collection.to_hash
@@ -117,7 +110,7 @@ module InventoryRefresh
         :retry_count             => retry_count,
         :retry_max               => retry_max,
         :total_parts             => total_parts,
-        :sweep_scope             => sweep_scope,
+        :sweep_scope             => sweep_scope_to_hash(sweep_scope),
         :collections             => collections_data,
       }
     end
@@ -127,22 +120,19 @@ module InventoryRefresh
       #
       # @param json_data [String] input JSON data
       # @return [ManageIQ::Providers::Inventory::Persister] Persister object loaded from a passed JSON
-      def from_json(json_data, manager, target = nil)
-        from_hash(JSON.parse(json_data), manager, target)
+      def from_json(json_data, manager)
+        from_hash(JSON.parse(json_data), manager)
       end
 
       # Returns Persister object built from serialized data
       #
       # @param persister_data [Hash] serialized Persister object in hash
       # @return [ManageIQ::Providers::Inventory::Persister] Persister object built from serialized data
-      def from_hash(persister_data, manager, target = nil)
-        # TODO(lsmola) we need to pass serialized targeted scope here
-        target ||= InventoryRefresh::TargetCollection.new(:manager => manager)
-
-        new(manager, target).tap do |persister|
+      def from_hash(persister_data, manager)
+        new(manager).tap do |persister|
           persister_data['collections'].each do |collection|
             inventory_collection = persister.collections[collection['name'].try(:to_sym)]
-            raise "Unrecognized InventoryCollection name: #{inventory_collection}" if inventory_collection.blank?
+            raise "Unrecognized InventoryCollection name: #{collection['name']}" if inventory_collection.blank?
 
             inventory_collection.from_hash(collection, persister.collections)
           end
@@ -152,9 +142,44 @@ module InventoryRefresh
           persister.retry_count             = persister_data['retry_count']
           persister.retry_max               = persister_data['retry_max']
           persister.total_parts             = persister_data['total_parts']
-          persister.sweep_scope             = persister_data['sweep_scope']
+          persister.sweep_scope             = sweep_scope_from_hash(persister_data['sweep_scope'], persister.collections)
         end
       end
+
+      private
+
+      def assert_sweep_scope!(sweep_scope)
+        return unless sweep_scope
+
+        allowed_format_message = "Allowed format of sweep scope is Array<String> or Hash{String => Hash}, got #{sweep_scope}"
+
+        if sweep_scope.kind_of?(Array)
+          return if sweep_scope.all? { |x| x.kind_of?(String) || x.kind_of?(Symbol) }
+
+          raise InventoryRefresh::Exception::SweeperScopeBadFormat, allowed_format_message
+        elsif sweep_scope.kind_of?(Hash)
+          return if sweep_scope.values.all? { |x| x.kind_of?(Array) }
+
+          raise InventoryRefresh::Exception::SweeperScopeBadFormat, allowed_format_message
+        end
+
+        raise InventoryRefresh::Exception::SweeperScopeBadFormat, allowed_format_message
+      end
+
+      def sweep_scope_from_hash(sweep_scope, available_inventory_collections)
+        assert_sweep_scope!(sweep_scope)
+
+        return sweep_scope unless sweep_scope.kind_of?(Hash)
+
+        sweep_scope.each_with_object({}) do |(k, v), obj|
+          inventory_collection = available_inventory_collections[k.try(:to_sym)]
+          raise "Unrecognized InventoryCollection name: #{k}" if inventory_collection.blank?
+
+          serializer = InventoryRefresh::InventoryCollection::Serialization.new(inventory_collection)
+
+          obj[k] = serializer.sweep_scope_from_hash(v, available_inventory_collections)
+        end.symbolize_keys!
+      end
     end
 
     protected
@@ -185,28 +210,37 @@ module InventoryRefresh
       nil
     end
 
-    def saver_strategy
-      :default
-    end
-
-    # Persisters for targeted refresh can override to true
-    def targeted?
+    def assert_graph_integrity?
       false
     end
 
-    def assert_graph_integrity?
-      false
+    def use_ar_object?
+      true
     end
 
     # @return [Hash] kwargs shared for all InventoryCollection objects
     def shared_options
       {
-        :saver_strategy         => saver_strategy,
         :strategy               => strategy,
-        :targeted               => targeted?,
         :parent                 => manager.presence,
         :assert_graph_integrity => assert_graph_integrity?,
+        :use_ar_object          => use_ar_object?,
       }
     end
+
+    private
+
+    def sweep_scope_to_hash(sweep_scope)
+      return sweep_scope unless sweep_scope.kind_of?(Hash)
+
+      sweep_scope.each_with_object({}) do |(k, v), obj|
+        inventory_collection = collections[k.try(:to_sym)]
+        raise "Unrecognized InventoryCollection name: #{k}" if inventory_collection.blank?
+
+        serializer = InventoryRefresh::InventoryCollection::Serialization.new(inventory_collection)
+
+        obj[k] = serializer.sweep_scope_to_hash(v)
+      end
+    end
   end
 end

data/lib/inventory_refresh/save_collection/base.rb

@@ -1,7 +1,5 @@
 require "inventory_refresh/logging"
-require "inventory_refresh/save_collection/saver/batch"
 require "inventory_refresh/save_collection/saver/concurrent_safe_batch"
-require "inventory_refresh/save_collection/saver/default"
 
 module InventoryRefresh::SaveCollection
   class Base
@@ -16,7 +14,7 @@ module InventoryRefresh::SaveCollection
         return if skip?(inventory_collection)
 
         logger.debug("----- BEGIN ----- Saving collection #{inventory_collection} of size #{inventory_collection.size} to"\
-                     " the database, for the manager: '#{ems.name}'...")
+                     " the database, for the manager: '#{ems.id}'...")
 
         if inventory_collection.custom_save_block.present?
           logger.debug("Saving collection #{inventory_collection} using a custom save block")
@@ -24,7 +22,7 @@ module InventoryRefresh::SaveCollection
         else
           save_inventory(inventory_collection)
         end
-        logger.debug("----- END ----- Saving collection #{inventory_collection}, for the manager: '#{ems.name}'...Complete")
+        logger.debug("----- END ----- Saving collection #{inventory_collection}, for the manager: '#{ems.id}'...Complete")
         inventory_collection.saved = true
       end
 

data/lib/inventory_refresh/save_collection/saver/base.rb

@@ -12,8 +12,6 @@ module InventoryRefresh::SaveCollection
       # @param inventory_collection [InventoryRefresh::InventoryCollection] InventoryCollection object we will be saving
       def initialize(inventory_collection)
         @inventory_collection = inventory_collection
-        # TODO(lsmola) do I need to reload every time? Also it should be enough to clear the associations.
-        inventory_collection.parent.reload if inventory_collection.parent
         @association = inventory_collection.db_collection_for_comparison
 
         # Private attrs
@@ -28,14 +26,10 @@ module InventoryRefresh::SaveCollection
         @unique_db_primary_keys = Set.new
         @unique_db_indexes      = Set.new
 
-        # Right now ApplicationRecordIterator in association is used for targeted refresh. Given the small amount of
-        # records flowing through there, we probably don't need to optimize that association to fetch a pure SQL.
-        @pure_sql_records_fetching = !inventory_collection.use_ar_object? && !@association.kind_of?(InventoryRefresh::ApplicationRecordIterator)
-
         @batch_size_for_persisting = inventory_collection.batch_size_pure_sql
+        @batch_size                = inventory_collection.use_ar_object? ? @batch_size_for_persisting : inventory_collection.batch_size
 
-        @batch_size          = @pure_sql_records_fetching ? @batch_size_for_persisting : inventory_collection.batch_size
-        @record_key_method   = @pure_sql_records_fetching ? :pure_sql_record_key : :ar_record_key
+        @record_key_method   = inventory_collection.pure_sql_record_fetching? ? :pure_sql_record_key : :ar_record_key
         @select_keys_indexes = @select_keys.each_with_object({}).with_index { |(key, obj), index| obj[key.to_s] = index }
         @pg_types            = @model_class.attribute_names.each_with_object({}) do |key, obj|
           obj[key.to_sym] = inventory_collection.model_class.columns_hash[key]
@@ -75,14 +69,8 @@ module InventoryRefresh::SaveCollection
 
       # Saves the InventoryCollection
       def save_inventory_collection!
-        # If we have a targeted InventoryCollection that wouldn't do anything, quickly skip it
-        return if inventory_collection.noop?
-
-        # Delete_complement strategy using :all_manager_uuids attribute
-        delete_complement unless inventory_collection.delete_complement_noop?
-
         # Create/Update/Archive/Delete records based on InventoryCollection data and scope
-        save!(association) unless inventory_collection.saving_noop?
+        save!(association)
       end
 
       protected
@@ -101,6 +89,8 @@ module InventoryRefresh::SaveCollection
       # @param attributes [Hash] attributes hash
       # @return [Hash] modified hash from parameter attributes with casted values
       def values_for_database!(all_attribute_keys, attributes)
+        # TODO(lsmola) we'll need to fill default value from the DB to the NOT_NULL columns here, since sending NULL
+        # to column with NOT_NULL constraint always fails, even if there is a default value
         all_attribute_keys.each do |key|
           next unless attributes.key?(key)
 
@@ -112,11 +102,7 @@ module InventoryRefresh::SaveCollection
       end
 
       def transform_to_hash!(all_attribute_keys, hash)
-        if inventory_collection.use_ar_object?
-          record = inventory_collection.model_class.new(hash)
-          values_for_database!(all_attribute_keys,
-                               record.attributes.slice(*record.changed_attributes.keys).symbolize_keys)
-        elsif serializable_keys?
+        if serializable_keys?
           values_for_database!(all_attribute_keys,
                                hash)
         else
@@ -127,101 +113,15 @@ module InventoryRefresh::SaveCollection
       private
 
       attr_reader :unique_index_keys, :unique_index_keys_to_s, :select_keys, :unique_db_primary_keys, :unique_db_indexes,
-                  :primary_key, :arel_primary_key, :record_key_method, :pure_sql_records_fetching, :select_keys_indexes,
+                  :primary_key, :arel_primary_key, :record_key_method, :select_keys_indexes,
                   :batch_size, :batch_size_for_persisting, :model_class, :serializable_keys, :deserializable_keys, :pg_types, :table_name,
                   :q_table_name
 
       delegate :supports_column?, :to => :inventory_collection
 
-      # Saves the InventoryCollection
-      #
-      # @param association [Symbol] An existing association on manager
-      def save!(association)
-        attributes_index        = {}
-        inventory_objects_index = {}
-        inventory_collection.each do |inventory_object|
-          attributes = inventory_object.attributes(inventory_collection)
-          index      = build_stringified_reference(attributes, unique_index_keys)
-
-          attributes_index[index]        = attributes
-          inventory_objects_index[index] = inventory_object
-        end
-
-        logger.debug("Processing #{inventory_collection} of size #{inventory_collection.size}...")
-        # Records that are in the DB, we will be updating or deleting them.
-        ActiveRecord::Base.transaction do
-          association.find_each do |record|
-            index = build_stringified_reference_for_record(record, unique_index_keys)
-
-            next unless assert_distinct_relation(record.id)
-            next unless assert_unique_record(record, index)
-
-            inventory_object = inventory_objects_index.delete(index)
-            hash             = attributes_index.delete(index)
-
-            if inventory_object.nil?
-              # Record was found in the DB but not sent for saving, that means it doesn't exist anymore and we should
-              # delete it from the DB.
-              delete_record!(record) if inventory_collection.delete_allowed?
-            else
-              # Record was found in the DB and sent for saving, we will be updating the DB.
-              update_record!(record, hash, inventory_object) if assert_referential_integrity(hash)
-            end
-          end
-        end
-
-        unless inventory_collection.custom_reconnect_block.nil?
-          inventory_collection.custom_reconnect_block.call(inventory_collection, inventory_objects_index, attributes_index)
-        end
-
-        # Records that were not found in the DB but sent for saving, we will be creating these in the DB.
-        if inventory_collection.create_allowed?
-          ActiveRecord::Base.transaction do
-            inventory_objects_index.each do |index, inventory_object|
-              hash = attributes_index.delete(index)
-
-              create_record!(hash, inventory_object) if assert_referential_integrity(hash)
-            end
-          end
-        end
-        logger.debug("Processing #{inventory_collection}, "\
-                     "created=#{inventory_collection.created_records.count}, "\
-                     "updated=#{inventory_collection.updated_records.count}, "\
-                     "deleted=#{inventory_collection.deleted_records.count}...Complete")
-      rescue => e
-        logger.error("Error when saving #{inventory_collection} with #{inventory_collection_details}. Message: #{e.message}")
-        raise e
-      end
-
       # @return [String] a string for logging purposes
       def inventory_collection_details
-        "strategy: #{inventory_collection.strategy}, saver_strategy: #{inventory_collection.saver_strategy}, targeted: #{inventory_collection.targeted?}"
-      end
-
-      # @param record [ApplicationRecord] ApplicationRecord object
-      # @param key [Symbol] A key that is an attribute of the AR object
-      # @return [Object] Value of attribute name :key on the :record
-      def record_key(record, key)
-        record.public_send(key)
-      end
-
-      # Deletes a complement of referenced data
-      def delete_complement
-        raise(":delete_complement method is supported only for :saver_strategy => [:batch, :concurrent_safe_batch]")
-      end
-
-      # Deletes/soft-deletes a given record
-      #
-      # @param [ApplicationRecord] record we want to delete
-      def delete_record!(record)
-        record.public_send(inventory_collection.delete_method)
-        inventory_collection.store_deleted_records(record)
-      end
-
-      # @return [TrueClass] always return true, this method is redefined in default saver
-      def assert_unique_record(_record, _index)
-        # TODO(lsmola) can go away once we indexed our DB with unique indexes
-        true
+        "strategy: #{inventory_collection.strategy}, saver_strategy: #{inventory_collection.saver_strategy}"
       end
 
       # Check if relation provided is distinct, i.e. the relation should not return the same primary key value twice.

data/lib/inventory_refresh/save_collection/saver/concurrent_safe_batch.rb

@@ -46,40 +46,6 @@ module InventoryRefresh::SaveCollection
         record[select_keys_indexes[key]]
       end
 
-      # Returns iterator or relation based on settings
-      #
-      # @param association [Symbol] An existing association on manager
-      # @return [ActiveRecord::Relation, InventoryRefresh::ApplicationRecordIterator] iterator or relation based on settings
-      def batch_iterator(association)
-        if pure_sql_records_fetching
-          # Building fast iterator doing pure SQL query and therefore avoiding redundant creation of AR objects. The
-          # iterator responds to find_in_batches, so it acts like the AR relation. For targeted refresh, the association
-          # can already be ApplicationRecordIterator, so we will skip that.
-          pure_sql_iterator = lambda do |&block|
-            primary_key_offset = nil
-            loop do
-              relation    = association.select(*select_keys)
-                                       .reorder("#{primary_key} ASC")
-                                       .limit(batch_size)
-              # Using rails way of comparing primary key instead of offset
-              relation    = relation.where(arel_primary_key.gt(primary_key_offset)) if primary_key_offset
-              records     = get_connection.query(relation.to_sql)
-              last_record = records.last
-              block.call(records)
-
-              break if records.size < batch_size
-              primary_key_offset = record_key(last_record, primary_key)
-            end
-          end
-
-          InventoryRefresh::ApplicationRecordIterator.new(:iterator => pure_sql_iterator)
-        else
-          # Normal Rails ActiveRecord::Relation where we can call find_in_batches or
-          # InventoryRefresh::ApplicationRecordIterator passed from targeted refresh
-          association
-        end
-      end
-
       # Saves the InventoryCollection
       #
       # @param association [Symbol] An existing association on manager
@@ -89,7 +55,7 @@ module InventoryRefresh::SaveCollection
         all_attribute_keys      = Set.new + inventory_collection.batch_extra_attributes
 
         inventory_collection.each do |inventory_object|
-          attributes = inventory_object.attributes_with_keys(inventory_collection, all_attribute_keys, inventory_object)
+          attributes = inventory_object.class.attributes_with_keys(inventory_object.data, inventory_collection, all_attribute_keys, inventory_object)
           index      = build_stringified_reference(attributes, unique_index_keys)
 
           # Interesting fact: not building attributes_index and using only inventory_objects_index doesn't do much
@@ -103,7 +69,7 @@ module InventoryRefresh::SaveCollection
         logger.debug("Processing #{inventory_collection} of size #{inventory_collection.size}...")
 
         unless inventory_collection.create_only?
-          update_or_destroy_records!(batch_iterator(association), inventory_objects_index, attributes_index, all_attribute_keys)
+          load_and_update_records!(association, inventory_objects_index, attributes_index, all_attribute_keys)
         end
 
         unless inventory_collection.create_only?
@@ -112,15 +78,11 @@ module InventoryRefresh::SaveCollection
 
         # Records that were not found in the DB but sent for saving, we will be creating these in the DB.
         if inventory_collection.create_allowed?
-          on_conflict = inventory_collection.parallel_safe? ? :do_update : nil
-
           inventory_objects_index.each_slice(batch_size_for_persisting) do |batch|
-            create_records!(all_attribute_keys, batch, attributes_index, :on_conflict => on_conflict)
+            create_records!(all_attribute_keys, batch, attributes_index, :on_conflict => :do_update)
           end
 
-          if inventory_collection.parallel_safe?
-            create_or_update_partial_records(all_attribute_keys)
-          end
+          create_or_update_partial_records(all_attribute_keys)
         end
 
         logger.debug("Marking :last_seen_at of #{inventory_collection} of size #{inventory_collection.size}...")
@@ -149,7 +111,7 @@ module InventoryRefresh::SaveCollection
       end
 
       def mark_last_seen_at(attributes_index)
-        return unless supports_column?(:last_seen_at) && inventory_collection.parallel_safe?
+        return unless supports_column?(:last_seen_at)
         return if attributes_index.blank?
 
         all_attribute_keys = [:last_seen_at]
@@ -162,8 +124,7 @@ module InventoryRefresh::SaveCollection
         get_connection.execute(query)
       end
 
-      # Batch updates existing records that are in the DB using attributes_index. And delete the ones that were not
-      # present in inventory_objects_index.
+      # Batch updates existing records that are in the DB using attributes_index.
       #
       # @param records_batch_iterator [ActiveRecord::Relation, InventoryRefresh::ApplicationRecordIterator] iterator or
       #        relation, both responding to :find_in_batches method
@@ -171,12 +132,11 @@ module InventoryRefresh::SaveCollection
       # @param attributes_index [Hash{String => Hash}] Hash of data hashes with only keys that are column names of the
       #        models's table
       # @param all_attribute_keys [Array<Symbol>] Array of all columns we will be saving into each table row
-      def update_or_destroy_records!(records_batch_iterator, inventory_objects_index, attributes_index, all_attribute_keys)
-        hashes_for_update   = []
-        records_for_destroy = []
+      def load_and_update_records!(records_batch_iterator, inventory_objects_index, attributes_index, all_attribute_keys)
+        hashes_for_update         = []
         indexed_inventory_objects = {}
 
-        records_batch_iterator.find_in_batches(:batch_size => batch_size) do |batch|
+        records_batch_iterator.find_in_batches(:batch_size => batch_size, :attributes_index => attributes_index) do |batch|
           update_time = time_now
 
           batch.each do |record|
@@ -189,20 +149,14 @@ module InventoryRefresh::SaveCollection
             inventory_object = inventory_objects_index.delete(index)
             hash             = attributes_index[index]
 
-            if inventory_object.nil?
-              # Record was found in the DB but not sent for saving, that means it doesn't exist anymore and we should
-              # delete it from the DB.
-              if inventory_collection.delete_allowed?
-                records_for_destroy << record
-              end
-            else
+            if inventory_object
               # Record was found in the DB and sent for saving, we will be updating the DB.
               inventory_object.id = primary_key_value
               next unless assert_referential_integrity(hash)
-              next unless changed?(record, hash, all_attribute_keys)
 
-              if inventory_collection.parallel_safe? &&
-                 (supports_remote_data_timestamp?(all_attribute_keys) || supports_remote_data_version?(all_attribute_keys))
+              record_version = nil
+              record_version_max = nil
+              if supports_remote_data_timestamp?(all_attribute_keys) || supports_remote_data_version?(all_attribute_keys)
 
                 version_attr, max_version_attr = if supports_remote_data_timestamp?(all_attribute_keys)
                                                    [:resource_timestamp, :resource_timestamps_max]
@@ -210,16 +164,16 @@ module InventoryRefresh::SaveCollection
                                                    [:resource_counter, :resource_counters_max]
                                                  end
 
-                next if skeletonize_or_skip_record(record_key(record, version_attr),
-                                                   hash[version_attr],
-                                                   record_key(record, max_version_attr),
-                                                   inventory_object)
+                record_version = record_key(record, version_attr.to_s)
+                record_version_max = record_key(record, max_version_attr.to_s)
               end
 
               hash_for_update = if inventory_collection.use_ar_object?
                                   record.assign_attributes(hash.except(:id))
+                                  next unless changed?(record)
+
                                   values_for_database!(all_attribute_keys,
-                                                       record.attributes.symbolize_keys)
+                                                       hash)
                                 elsif serializable_keys?
                                   # TODO(lsmola) hash data with current DB data to allow subset of data being sent,
                                   # otherwise we would nullify the not sent attributes. Test e.g. on disks in cloud
@@ -230,6 +184,14 @@ module InventoryRefresh::SaveCollection
                                   # otherwise we would nullify the not sent attributes. Test e.g. on disks in cloud
                                   hash
                                 end
+
+              if supports_remote_data_timestamp?(all_attribute_keys) || supports_remote_data_version?(all_attribute_keys)
+                next if skeletonize_or_skip_record(record_version,
+                                                   hash[version_attr],
+                                                   record_version_max,
+                                                   inventory_object)
+              end
+
               assign_attributes_for_update!(hash_for_update, update_time)
 
               hash_for_update[:id] = primary_key_value
@@ -245,39 +207,20 @@ module InventoryRefresh::SaveCollection
             hashes_for_update = []
             indexed_inventory_objects = {}
           end
-
-          # Destroy in batches
-          if records_for_destroy.size >= batch_size_for_persisting
-            destroy_records!(records_for_destroy)
-            records_for_destroy = []
-          end
         end
 
         # Update the last batch
         update_records!(all_attribute_keys, hashes_for_update, indexed_inventory_objects)
         hashes_for_update = [] # Cleanup so GC can release it sooner
-
-        # Destroy the last batch
-        destroy_records!(records_for_destroy)
-        records_for_destroy = [] # Cleanup so GC can release it sooner
       end
 
-      def changed?(_record, _hash, _all_attribute_keys)
+      def changed?(record)
         return true unless inventory_collection.check_changed?
 
-        # TODO(lsmola) this check needs to be disabled now, because it doesn't work with lazy_find having secondary
-        # indexes. Examples: we save a pod before we save a project, that means the project lazy_find won't evaluate,
-        # because we load it with secondary index and can't do skeletal precreate. Then when the object is being saved
-        # again, the lazy_find is evaluated, but the resource version is not changed, so the row is not saved.
-        #
-        # To keep this quick .changed? check, we might need to extend this, so the resource_version doesn't save until
-        # all lazy_links of the row are evaluated.
-        #
-        # if supports_resource_version?(all_attribute_keys) && supports_column?(resource_version_column)
-        #   record_resource_version = record_key(record, resource_version_column.to_s)
-        #
-        #   return record_resource_version != hash[resource_version_column]
-        # end
+        # Skip if nothing changed
+        return false if record.changed_attributes.empty?
+        # Skip if we only changed the resource_timestamp, but data stays the same
+        return false if record.changed_attributes.keys == ["resource_timestamp"]
 
         true
       end
@@ -285,10 +228,7 @@ module InventoryRefresh::SaveCollection
       def db_columns_index(record, pure_sql: false)
         # Incoming values are in SQL string form.
         # TODO(lsmola) unify this behavior with object_index_with_keys method in InventoryCollection
-        # TODO(lsmola) maybe we can drop the whole pure sql fetching, since everything will be targeted refresh
         # with streaming refresh? Maybe just metrics and events will not be, but those should be upsert only
-        # TODO(lsmola) taking ^ in account, we can't drop pure sql, since that is returned by batch insert and
-        # update queries
         unique_index_keys_to_s.map do |attribute|
           value = if pure_sql
                     record[attribute]
@@ -319,20 +259,13 @@ module InventoryRefresh::SaveCollection
       def update_records!(all_attribute_keys, hashes, indexed_inventory_objects)
         return if hashes.blank?
 
-        unless inventory_collection.parallel_safe?
-          # We need to update the stored records before we save it, since hashes are modified
-          inventory_collection.store_updated_records(hashes)
-        end
-
         query = build_update_query(all_attribute_keys, hashes)
         result = get_connection.execute(query)
 
-        if inventory_collection.parallel_safe?
-          # We will check for timestamp clashes of full row update and we will fallback to skeletal update
-          inventory_collection.store_updated_records(result)
+        # We will check for timestamp clashes of full row update and we will fallback to skeletal update
+        inventory_collection.store_updated_records(result)
 
-          skeletonize_ignored_records!(indexed_inventory_objects, result)
-        end
+        skeletonize_ignored_records!(indexed_inventory_objects, result)
 
         result
       end
@@ -352,11 +285,7 @@ module InventoryRefresh::SaveCollection
         hashes                    = []
         create_time               = time_now
         batch.each do |index, inventory_object|
-          hash = if inventory_collection.use_ar_object?
-                   record = inventory_collection.model_class.new(attributes_index[index])
-                   values_for_database!(all_attribute_keys,
-                                        record.attributes.symbolize_keys)
-                 elsif serializable_keys?
+          hash = if serializable_keys?
                    values_for_database!(all_attribute_keys,
                                         attributes_index[index])
                  else
@@ -378,24 +307,19 @@ module InventoryRefresh::SaveCollection
           build_insert_query(all_attribute_keys, hashes, :on_conflict => on_conflict, :mode => :full)
         )
 
-        if inventory_collection.parallel_safe?
-          # We've done upsert, so records were either created or updated. We can recognize that by checking if
-          # created and updated timestamps are the same
-          created_attr = "created_on" if inventory_collection.supports_column?(:created_on)
-          created_attr ||= "created_at" if inventory_collection.supports_column?(:created_at)
-          updated_attr = "updated_on" if inventory_collection.supports_column?(:updated_on)
-          updated_attr ||= "updated_at" if inventory_collection.supports_column?(:updated_at)
-
-          if created_attr && updated_attr
-            created, updated = result.to_a.partition { |x| x[created_attr] == x[updated_attr] }
-            inventory_collection.store_created_records(created)
-            inventory_collection.store_updated_records(updated)
-          else
-            # The record doesn't have both created and updated attrs, so we'll take all as created
-            inventory_collection.store_created_records(result)
-          end
+        # We've done upsert, so records were either created or updated. We can recognize that by checking if
+        # created and updated timestamps are the same
+        created_attr = "created_on" if inventory_collection.supports_column?(:created_on)
+        created_attr ||= "created_at" if inventory_collection.supports_column?(:created_at)
+        updated_attr = "updated_on" if inventory_collection.supports_column?(:updated_on)
+        updated_attr ||= "updated_at" if inventory_collection.supports_column?(:updated_at)
+
+        if created_attr && updated_attr
+          created, updated = result.to_a.partition { |x| x[created_attr] == x[updated_attr] }
+          inventory_collection.store_created_records(created)
+          inventory_collection.store_updated_records(updated)
         else
-          # We've done just insert, so all records were created
+          # The record doesn't have both created and updated attrs, so we'll take all as created
           inventory_collection.store_created_records(result)
         end
 
@@ -408,9 +332,7 @@ module InventoryRefresh::SaveCollection
                                        :on_conflict => on_conflict)
         end
 
-        if inventory_collection.parallel_safe?
-          skeletonize_ignored_records!(indexed_inventory_objects, result, :all_unique_columns => true)
-        end
+        skeletonize_ignored_records!(indexed_inventory_objects, result, :all_unique_columns => true)
       end
 
       # Stores primary_key values of created records into associated InventoryObject objects.