torque-postgresql 2.0.4 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f108bfb672743d7edd701b77eb102aa6f9164b4981e1f366d2354d9e8cf3360b
-  data.tar.gz: 60d7208f0798acbde69aee78fca7a92d4824c75dcecc44acd16dcf59568f0e04
+  metadata.gz: 83fb6f6620a916f7ef85af51f4ba4fa6e2a1c6b3597ee5884466e4d46b6544c6
+  data.tar.gz: 7503abd9ce29bd38349d88527502abc51182bb5e158e0f1960b71817d65cd559
 SHA512:
-  metadata.gz: 0a463f94c5a09f74bbb2ba57fe9fb2f7fe649f243c239f7709180c29988f2b5424bffec68d0ec1d2c4ae8ad1191d6156e96dd00c2a66a2a473e02411c563e21f
-  data.tar.gz: 1568915cd13e2b93b77a702cfd346326aa9e07605aac3deca0f3dacbe82b24762a84f3007a4dffc493888c94802724defbfc01037d0bad984e3735783a790f35
+  metadata.gz: 13c371dccc04ee5663e2d249a443f398005a1d2e2cabea904c03f34c379ee4119c5ec5c7edeee52ef009d5223df9b514b6444b1ffeff9fc3231adbba93aebd5a
+  data.tar.gz: c8308c9290b8bac1ee2d990ec64e128cdeed903d09dbc391b23eb5867930c41febc1affaf043840c81675642bebd027e1a6bdf7400c4375c23cfe111496ee174

data/lib/torque/postgresql.rb

@@ -22,7 +22,7 @@ require 'torque/postgresql/autosave_association'
 require 'torque/postgresql/auxiliary_statement'
 require 'torque/postgresql/base'
 require 'torque/postgresql/inheritance'
-require 'torque/postgresql/coder'
+require 'torque/postgresql/insert_all'
 require 'torque/postgresql/migration'
 require 'torque/postgresql/relation'
 require 'torque/postgresql/reflection'

data/lib/torque/postgresql/adapter.rb

@@ -15,6 +15,8 @@ module Torque
       include DatabaseStatements
       include SchemaStatements
 
+      INJECT_WHERE_REGEX = /(DO UPDATE SET.*excluded\.[^ ]+) RETURNING/.freeze
+
       # Get the current PostgreSQL version as a Gem Version.
       def version
         @version ||= Gem::Version.new(
@@ -26,6 +28,20 @@ module Torque
       def extract_table_options!(options)
         super.merge(options.extract!(:inherits))
       end
+
+      # Allow filtered bulk insert by adding the where clause. This method is only used by
+      # +InsertAll+, so it somewhat safe to override it
+      def build_insert_sql(insert)
+        super.tap do |sql|
+          if insert.update_duplicates? && insert.where_condition?
+            if insert.returning
+              sql.gsub!(INJECT_WHERE_REGEX, "\\1 WHERE #{insert.where} RETURNING")
+            else
+              sql << " WHERE #{insert.where}"
+            end
+          end
+        end
+      end
     end
 
     ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend Adapter

data/lib/torque/postgresql/adapter/database_statements.rb

@@ -123,7 +123,7 @@ module Torque
           SQL
 
           tables.map do |(table, refs)|
-            [table, Coder.decode(refs)]
+            [table, PG::TextDecoder::Array.new.decode(refs)]
           end.to_h
         end
 
@@ -147,20 +147,6 @@ module Torque
           SQL
         end
 
-        # Extracts the value from a PostgreSQL column default definition.
-        def extract_value_from_default(default)
-          case default
-            # Array elements
-          when /\AARRAY\[(.*)\]\z/
-            # TODO: Improve this since it's not the most safe approach
-            eval(default.gsub(/ARRAY|::\w+(\[\])?/, ''))
-          else
-            super
-          end
-        rescue SyntaxError
-          # If somethin goes wrong with the eval, just return nil
-        end
-
       end
     end
   end

data/lib/torque/postgresql/adapter/schema_dumper.rb

@@ -43,13 +43,13 @@ module Torque
             inherited_tables = @connection.inherited_tables
             sorted_tables = @connection.tables.sort - @connection.views
 
-            stream.puts "  # These are the common tables managed"
+            stream.puts "  # These are the common tables"
             (sorted_tables - inherited_tables.keys).each do |table_name|
               table(table_name, stream) unless ignored?(table_name)
             end
 
             if inherited_tables.present?
-              stream.puts "  # These are tables that has inheritance"
+              stream.puts "  # These are tables that have inheritance"
               inherited_tables.each do |table_name, inherits|
                 next if ignored?(table_name)
 
@@ -78,6 +78,10 @@ module Torque
 
             # Scenic integration
             views(stream) if defined?(::Scenic)
+
+            # FX integration
+            functions(stream) if defined?(::Fx::SchemaDumper::Function)
+            triggers(stream) if defined?(::Fx::SchemaDumper::Trigger)
           end
 
           # Dump user defined types like enum

data/lib/torque/postgresql/associations/association.rb

@@ -5,6 +5,8 @@ module Torque
     module Associations
       module Association
 
+        # There is no problem of adding temporary items on target because
+        # CollectionProxy will handle memory and persisted relationship
         def inversed_from(record)
           return super unless reflection.connected_through_array?
 
@@ -13,15 +15,20 @@ module Torque
           @inversed = self.target.present?
         end
 
+        # The binds and the cache are getting mixed and caching the wrong query
+        def skip_statement_cache?(*)
+          super || reflection.connected_through_array?
+        end
+
         private
 
+          # This is mainly for the has many when connect through an array to add
+          # its id to the list of the inverse belongs to many association
           def set_owner_attributes(record)
             return super unless reflection.connected_through_array?
 
             add_id = owner[reflection.active_record_primary_key]
-            record_fk = reflection.foreign_key
-
-            list = record[record_fk] ||= []
+            list = record[reflection.foreign_key] ||= []
             list.push(add_id) unless list.include?(add_id)
           end
 

data/lib/torque/postgresql/associations/belongs_to_many_association.rb

@@ -9,10 +9,71 @@ module Torque
       class BelongsToManyAssociation < ::ActiveRecord::Associations::CollectionAssociation
         include ::ActiveRecord::Associations::ForeignAssociation
 
+        ## CUSTOM
+        def ids_reader
+          if loaded?
+            target.pluck(reflection.association_primary_key)
+          elsif !target.empty?
+            load_target.pluck(reflection.association_primary_key)
+          else
+            stale_state || column_default_value
+          end
+        end
+
+        def ids_writer(ids)
+          ids = ids.presence || column_default_value
+          owner.write_attribute(source_attr, ids)
+          return unless owner.persisted? && owner.attribute_changed?(source_attr)
+
+          owner.update_attribute(source_attr, ids)
+        end
+
+        def size
+          if loaded?
+            target.size
+          elsif !target.empty?
+            unsaved_records = target.select(&:new_record?)
+            unsaved_records.size + stale_state.size
+          else
+            stale_state&.size || 0
+          end
+        end
+
+        def empty?
+          size.zero?
+        end
+
+        def include?(record)
+          return false unless record.is_a?(reflection.klass)
+          return include_in_memory?(record) if record.new_record?
+
+          (!target.empty? && target.include?(record)) ||
+            stale_state&.include?(record.read_attribute(klass_attr))
+        end
+
+        def load_target
+          if stale_target? || find_target?
+            @target = merge_target_lists(find_target, target)
+          end
+
+          loaded!
+          target
+        end
+
+        def build_changes(from_target = false)
+          return yield if defined?(@_building_changes) && @_building_changes
+
+          @_building_changes = true
+          yield.tap { ids_writer(from_target ? ids_reader : stale_state) }
+        ensure
+          @_building_changes = nil
+        end
+
+        ## HAS MANY
         def handle_dependency
           case options[:dependent]
           when :restrict_with_exception
-            raise ::ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
+            raise ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
 
           when :restrict_with_error
             unless empty?
@@ -22,86 +83,89 @@ module Torque
             end
 
           when :destroy
-            # No point in executing the counter update since we're going to destroy the parent anyway
             load_target.each { |t| t.destroyed_by_association = reflection }
             destroy_all
+          when :destroy_async
+            load_target.each do |t|
+              t.destroyed_by_association = reflection
+            end
+
+            unless target.empty?
+              association_class = target.first.class
+              primary_key_column = association_class.primary_key.to_sym
+
+              ids = target.collect do |assoc|
+                assoc.public_send(primary_key_column)
+              end
+
+              enqueue_destroy_association(
+                owner_model_name: owner.class.to_s,
+                owner_id: owner.id,
+                association_class: association_class.to_s,
+                association_ids: ids,
+                association_primary_key_column: primary_key_column,
+                ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+              )
+            end
           else
             delete_all
           end
         end
 
-        def ids_reader
-          owner[source_attr]
-        end
-
-        def ids_writer(new_ids)
-          column = source_attr
-          command = owner.persisted? ? :update_column : :write_attribute
-          owner.public_send(command, column, new_ids.presence)
-          @association_scope = nil
-        end
-
         def insert_record(record, *)
-          super
-
-          attribute = (ids_reader || owner[source_attr] = [])
-          attribute.push(record[klass_attr])
-          record
-        end
-
-        def empty?
-          size.zero?
+          (record.persisted? || super).tap do |saved|
+            ids_rewriter(record.read_attribute(klass_attr), :<<) if saved
+          end
         end
 
-        def include?(record)
-          list = owner[source_attr]
-          ids_reader && ids_reader.include?(record[klass_attr])
+        ## BELONGS TO
+        def default(&block)
+          writer(owner.instance_exec(&block)) if reader.nil?
         end
 
         private
 
-          # Returns the number of records in this collection, which basically
-          # means count the number of entries in the +primary_key+
-          def count_records
-            ids_reader&.size || (@target ||= []).size
+          ## CUSTOM
+          def _create_record(attributes, raises = false, &block)
+            if attributes.is_a?(Array)
+              attributes.collect { |attr| _create_record(attr, raises, &block) }
+            else
+              build_record(attributes, &block).tap do |record|
+                transaction do
+                  result = nil
+                  add_to_target(record) do
+                    result = insert_record(record, true, raises) { @_was_loaded = loaded? }
+                  end
+                  raise ActiveRecord::Rollback unless result
+                end
+              end
+            end
           end
 
-          # When the idea is to nulligy the association, then just set the owner
+          # When the idea is to nullify the association, then just set the owner
           # +primary_key+ as empty
-          def delete_count(method, scope, ids = nil)
-            ids ||= scope.pluck(klass_attr)
-            scope.delete_all if method == :delete_all
-            remove_stash_records(ids)
+          def delete_count(method, scope, ids)
+            size_cache = scope.delete_all if method == :delete_all
+            (size_cache || ids.size).tap { ids_rewriter(ids, :-) }
           end
 
           def delete_or_nullify_all_records(method)
-            delete_count(method, scope)
+            delete_count(method, scope, ids_reader)
           end
 
           # Deletes the records according to the <tt>:dependent</tt> option.
           def delete_records(records, method)
-            ids = Array.wrap(records).each_with_object(klass_attr).map(&:[])
+            ids = read_records_ids(records)
 
             if method == :destroy
               records.each(&:destroy!)
-              remove_stash_records(ids)
+              ids_rewriter(ids, :-)
             else
               scope = self.scope.where(klass_attr => records)
               delete_count(method, scope, ids)
             end
           end
 
-          def concat_records(*)
-            result = super
-            ids_writer(ids_reader)
-            result
-          end
-
-          def remove_stash_records(ids)
-            return if ids_reader.nil?
-            ids_writer(ids_reader - Array.wrap(ids))
-          end
-
           def source_attr
             reflection.foreign_key
           end
@@ -110,6 +174,37 @@ module Torque
             reflection.active_record_primary_key
           end
 
+          def read_records_ids(records)
+            return unless records.present?
+            Array.wrap(records).each_with_object(klass_attr).map(&:read_attribute).presence
+          end
+
+          def ids_rewriter(ids, operator)
+            list = owner[source_attr] ||= []
+            list = list.public_send(operator, ids)
+            owner[source_attr] = list.uniq.compact.presence || column_default_value
+
+            return if @_building_changes || !owner.persisted?
+            owner.update_attribute(source_attr, list)
+          end
+
+          def column_default_value
+            owner.class.columns_hash[source_attr].default
+          end
+
+          ## HAS MANY
+          def replace_records(*)
+            build_changes(true) { super }
+          end
+
+          def concat_records(*)
+            build_changes(true) { super }
+          end
+
+          def delete_or_destroy(*)
+            build_changes(true) { super }
+          end
+
           def difference(a, b)
             a - b
           end
@@ -117,6 +212,28 @@ module Torque
           def intersection(a, b)
             a & b
           end
+
+          ## BELONGS TO
+          def scope_for_create
+            super.except!(klass.primary_key)
+          end
+
+          def find_target?
+            !loaded? && foreign_key_present? && klass
+          end
+
+          def foreign_key_present?
+            stale_state.present?
+          end
+
+          def invertible_for?(record)
+            inverse = inverse_reflection_for(record)
+            inverse && (inverse.has_many? && inverse.connected_through_array?)
+          end
+
+          def stale_state
+            owner.read_attribute(source_attr)
+          end
       end
 
       ::ActiveRecord::Associations.const_set(:BelongsToManyAssociation, BelongsToManyAssociation)

data/lib/torque/postgresql/associations/builder/belongs_to_many.rb

@@ -57,12 +57,9 @@ module Torque
               end
             end
 
-            unless reflection.counter_cache_column
-              model.after_create callback.call(:saved_changes), if: :saved_changes?
-              model.after_destroy callback.call(:changes_to_save)
-            end
-
+            model.after_create callback.call(:saved_changes), if: :saved_changes?
             model.after_update callback.call(:saved_changes), if: :saved_changes?
+            model.after_destroy callback.call(:changes_to_save)
             model.after_touch callback.call(:changes_to_save)
           end
 
@@ -97,6 +94,10 @@ module Torque
             end
           end
 
+          def self.add_destroy_callbacks(model, reflection)
+            model.after_destroy lambda { |o| o.association(reflection.name).handle_dependency }
+          end
+
           def self.define_validations(model, reflection)
             if reflection.options.key?(:required)
               reflection.options[:optional] = !reflection.options.delete(:required)

data/lib/torque/postgresql/associations/preloader/association.rb

@@ -35,6 +35,7 @@ module Torque
                 ids.each { |id| records[id].concat(Array.wrap(record)) }
               end
 
+              records.default_proc = nil
               owners.each do |owner|
                 associate_records_to_owner(owner, records[owner[owner_key_name]] || [])
               end