torque-postgresql 4.0.1 → 4.1.1

data/lib/torque/postgresql/inheritance.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'inheritance/record'
+require_relative 'inheritance/expander'
+
 module Torque
   module PostgreSQL
     InheritanceError = Class.new(ArgumentError)
@@ -7,25 +10,12 @@ module Torque
     module Inheritance
       extend ActiveSupport::Concern
 
-      # Cast the given object to its correct class
-      def cast_record
-        record_class_value = send(self.class._record_class_attribute)
-
-        return self unless self.class.table_name != record_class_value
-        klass = self.class.casted_dependents[record_class_value]
-        self.class.raise_unable_to_cast(record_class_value) if klass.nil?
-
-        # The record need to be re-queried to have its attributes loaded
-        # :TODO: Improve this by only loading the necessary extra columns
-        klass.find(self.id)
-      end
-
       class_methods do
-        delegate :_auto_cast_attribute, :_record_class_attribute, to: ActiveRecord::Relation
+        delegate :_record_class_attribute, :_record_class_column_name, to: ActiveRecord::Relation
 
         # Get a full list of all attributes from a model and all its dependents
         def inheritance_merged_attributes
-          @inheritance_merged_attributes ||= begin
+          inheritance_cache(:@inheritance_merged_attributes) do
             children = casted_dependents.values.flat_map(&:attribute_names)
             attribute_names.to_set.merge(children).to_a.freeze
           end
@@ -34,7 +24,7 @@ module Torque
         # Get the list of attributes that can be merged while querying because
         # they all have the same type
         def inheritance_mergeable_attributes
-          @inheritance_mergeable_attributes ||= begin
+          inheritance_cache(:@inheritance_mergeable_attributes) do
             base = inheritance_merged_attributes - attribute_names
             types = base.zip(base.size.times.map { [] }).to_h
 
@@ -54,11 +44,11 @@ module Torque
 
         # Check if the model's table depends on any inheritance
         def physically_inherited?
-          return @physically_inherited if defined?(@physically_inherited)
-
-          @physically_inherited = connection.schema_cache.dependencies(
-            defined?(@table_name) ? @table_name : decorated_table_name,
-          ).present?
+          inheritance_cache(:@physically_inherited) do
+            connection_pool.schema_cache.dependencies(
+              defined?(@table_name) ? @table_name : decorated_table_name,
+            ).present?
+          end
         rescue ActiveRecord::ConnectionNotEstablished
           false
         end
@@ -66,20 +56,63 @@ module Torque
         # Get the list of all tables directly or indirectly dependent of the
         # current one
         def inheritance_dependents
-          connection.schema_cache.associations(table_name) || []
+          connection_pool.schema_cache.associations(table_name) || []
         end
 
         # Check whether the model's table has directly or indirectly dependents
         def physically_inheritances?
-          inheritance_dependents.present?
+          inheritance_cache(:@physically_inheritances) { inheritance_dependents.present? }
+        end
+
+        # The prefix that identifies the columns of this table when they are
+        # loaded next to the columns of a sibling table
+        def inheritance_column_prefix
+          inheritance_cache(:@inheritance_column_prefix) { "#{table_name}__".freeze }
+        end
+
+        # The topmost class of this class' physical inheritance family, which
+        # is what casted_dependents needs to be called on to see every
+        # dependent in the family rather than just this class' own descendants
+        def physically_inheritance_root
+          physically_inherited? ? superclass.physically_inheritance_root : self
+        end
+
+        # The columns that belong to other dependents of this class' physical
+        # inheritance family, which must never land on one of its casted
+        # records because they belong to a sibling, not to this class
+        def inheritance_foreign_attribute_names
+          inheritance_cache(:@inheritance_foreign_attribute_names) do
+            (physically_inheritance_root.inheritance_merged_attributes - attribute_names).to_set.freeze
+          end
+        end
+
+        # The exact "table_name__" prefixes build_inheritances emits for a
+        # non-mergeable column of any dependent in this class' physical
+        # inheritance family, which is what a joined sibling column looks like
+        def inheritance_dependent_prefixes
+          inheritance_cache(:@inheritance_dependent_prefixes) do
+            physically_inheritance_root.casted_dependents.keys.map { |name| "#{name}__" }.to_set.freeze
+          end
         end
 
         # Get the list of all ActiveRecord classes directly or indirectly
         # associated by inheritance
         def casted_dependents
-          @casted_dependents ||= inheritance_dependents.map do |table_name|
-            [table_name, connection.schema_cache.lookup_model(table_name)]
-          end.to_h
+          inheritance_cache(:@casted_dependents) do
+            inheritance_dependents.map do |table_name|
+              [table_name, connection_pool.schema_cache.lookup_model(table_name)]
+            end.to_h.freeze
+          end
+        end
+
+        # Get the dependents that actually add columns, which are the only ones
+        # that produce incomplete records when loaded from this table
+        def inheritance_expandable_dependents
+          inheritance_cache(:@inheritance_expandable_dependents) do
+            casted_dependents.select do |_table_name, klass|
+              (klass.attribute_names - attribute_names).any?
+            end.freeze
+          end
         end
 
         # Manually set the model name associated with tables name in order to
@@ -88,8 +121,8 @@ module Torque
           table = super
 
           adapter = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-          if Torque::PostgreSQL.config.eager_load && connection.is_a?(adapter)
-            connection.schema_cache.add_model_name(table, self)
+          if Torque::PostgreSQL.config.eager_load && connection_pool.db_config.adapter_class <= adapter
+            connection_pool.schema_cache.add_model_name(table, self)
           end
 
           table
@@ -125,73 +158,113 @@ module Torque
           physically_inherited? ? decorated_table_name : super
         end
 
-        # Raises an error message saying that the giver record class was not
-        # able to be casted since the model was not identified
+        # Raises an error message saying that the given record class could not
+        # be instantiated since the model was not identified
         def raise_unable_to_cast(record_class_value)
           raise InheritanceError.new(<<~MSG.squish)
-            An record was not able to be casted to type '#{record_class_value}'.
+            A record could not be instantiated as '#{record_class_value}'.
             If this table name doesn't represent a guessable model,
             please use 'Torque::PostgreSQL.conf.irregular_models =
             { '#{record_class_value}' => 'ModelName' }'.
           MSG
         end
 
+        protected
+
+          # Inheritance metadata is derived from the schema, so it must be
+          # dropped whenever ActiveRecord drops its own schema-derived caches
+          def reload_schema_from_cache(recursive = true)
+            @physically_inherited = nil
+            @physically_inheritances = nil
+            @casted_dependents = nil
+            @inheritance_merged_attributes = nil
+            @inheritance_mergeable_attributes = nil
+            @inheritance_expandable_dependents = nil
+            @inheritance_column_prefix = nil
+            @inheritance_foreign_attribute_names = nil
+            @inheritance_dependent_prefixes = nil
+            super
+          end
+
         private
 
-          # If the class is physically inherited, the klass needs to be properly
-          # changed before moving forward
+          # Memoize using double-checked locking against ActiveRecord's own
+          # monitor for loading the schema
+          def inheritance_cache(name)
+            current = instance_variable_get(name)
+            return current unless current.nil?
+
+            # why: @load_schema_monitor is still nil while AR's inherited reaches base_class
+            (@load_schema_monitor ||= Monitor.new).synchronize do
+              current = instance_variable_get(name)
+              return current unless current.nil?
+
+              instance_variable_set(name, yield)
+            end
+          end
+
+          # Rows coming from a table with dependents carry the table they were
+          # stored in, which is what decides the class to instantiate
           def instantiate_instance_of(klass, attributes, types = {}, &block)
             return super unless klass.physically_inheritances?
 
-            real_class = torque_discriminate_class_for_record(klass, attributes)
-            return super if real_class.nil?
+            marker = _record_class_column_name
+            record_class = attributes[marker]
+            if record_class.blank? || record_class == klass.table_name
+              values, types = sanitize_attributes(klass, attributes, types)
+              return super(klass, values, types, &block)
+            end
 
-            attributes, types = sanitize_attributes(real_class, attributes, types)
-            super(real_class, attributes, types, &block)
+            real_class = klass.casted_dependents[record_class]
+            klass.raise_unable_to_cast(record_class) if real_class.nil?
+
+            values, types = sanitize_attributes(real_class, attributes, types)
+            record = super(real_class, values, types, &block)
+
+            # why: expand_records may already join in real_class's own columns
+            if klass.inheritance_expandable_dependents.key?(record_class)
+              incomplete = real_class.attribute_names.any? { |name| !values.key?(name) }
+              record.send(:mark_as_partial_record!) if incomplete
+            end
+
+            record
           end
 
-          # Unwrap the attributes and column types from the given class when
-          # there are unmergeable attributes
+          # Drop what is known to be foreign: the internal record class column
+          # and the columns prefixed with another dependent table of the same
+          # family, unwrapping our own prefix and letting everything else
+          # through, including a user alias that happens to contain '__'
           def sanitize_attributes(real_class, attributes, types)
-            skip = (inheritance_merged_attributes - real_class.attribute_names).to_set
-            skip.merge(real_class.attribute_names - inheritance_mergeable_attributes)
-            return [attributes, types] if skip.empty?
+            prefix = real_class.inheritance_column_prefix
+            sibling_prefixes = real_class.inheritance_dependent_prefixes
+            foreign = real_class.inheritance_foreign_attribute_names
+            skip = _record_class_column_name
 
-            dropped = 0
+            new_values = {}
             new_types = {}
 
-            row = attributes.instance_variable_get(:@row).dup
-            indexes = attributes.instance_variable_get(:@column_indexes).dup
-            indexes = indexes.each_with_object({}) do |(column, index), new_indexes|
-              attribute, prefix = column.split('__', 2).reverse
-              current_index = index - dropped
-
-              if prefix != table_name && skip.include?(attribute)
-                row.delete_at(current_index)
-                dropped += 1
-              else
-                new_types.merge!(types.slice(attribute))
-                new_types[current_index] = types[index]
-                new_indexes[attribute] = current_index
-              end
-            end
-
-            [ActiveRecord::Result::IndexedRow.new(indexes, row), new_types]
-          end
+            attributes.to_hash.each do |column, value|
+              next if column == skip || foreign.include?(column)
 
-          # Get the real class when handling physical inheritances and casting
-          # the record when existing properly is present
-          def torque_discriminate_class_for_record(klass, record)
-            return if record[_auto_cast_attribute.to_s] == false
+              name =
+                if column.start_with?(prefix)
+                  column.delete_prefix(prefix)
+                elsif sibling_prefixes.any? { |sibling_prefix| column.start_with?(sibling_prefix) }
+                  next
+                else
+                  column
+                end
 
-            embedded_type = record[_record_class_attribute.to_s]
-            return if embedded_type.blank? || embedded_type == table_name
+              new_values[name] = value
+              new_types[name] = types[column] if types.key?(column)
+            end
 
-            casted_dependents[embedded_type] || raise_unable_to_cast(embedded_type)
+            [new_values, new_types]
           end
       end
     end
 
     ActiveRecord::Base.include Inheritance
+    ActiveRecord::Base.include Inheritance::Record
   end
 end

data/lib/torque/postgresql/migration/command_recorder.rb

@@ -15,6 +15,82 @@ module Torque
           [:rename_type, args.reverse]
         end
 
+        # Records the creation of a composite type
+        def create_composite_type(*args, &block)
+          record(:create_composite_type, args, &block)
+        end
+
+        # Inverts the creation of a composite type
+        def invert_create_composite_type(args)
+          options = args.second.try(:slice, :schema) || {}
+          [:drop_type, [args.first, options]]
+        end
+
+        # Records changes to a composite type, which cannot be inverted for the
+        # same reason as +change_table+
+        def change_composite_type(*args, &block)
+          record(:change_composite_type, args, &block)
+        end
+
+        # Records a column being added to a composite type
+        def add_composite_column(*args, &block)
+          record(:add_composite_column, args, &block)
+        end
+
+        # Inverts a column being added to a composite type
+        def invert_add_composite_column(args)
+          [:remove_composite_column, args]
+        end
+
+        # Records a column being removed from a composite type
+        def remove_composite_column(*args, &block)
+          record(:remove_composite_column, args, &block)
+        end
+
+        # Inverts a column being removed from a composite type, which is only
+        # possible when its type was informed
+        def invert_remove_composite_column(args)
+          raise ActiveRecord::IrreversibleMigration, <<~MSG.squish if args.third.nil?
+            remove_composite_column is only reversible if given a type.
+          MSG
+
+          [:add_composite_column, args]
+        end
+
+        # Records the type of a column being changed, which cannot be inverted
+        # because the previous type is unknown
+        def change_composite_column(*args, &block)
+          record(:change_composite_column, args, &block)
+        end
+
+        # Records a column of a composite type being renamed
+        def rename_composite_column(*args, &block)
+          record(:rename_composite_column, args, &block)
+        end
+
+        # Inverts a column of a composite type being renamed
+        def invert_rename_composite_column(args)
+          [:rename_composite_column, [args.first, args.third, args.second, *args[3..]]]
+        end
+
+        # Records the spread of features into inherited tables. While reverting,
+        # the pruning form goes to the front of the list, which is played back
+        # reversed, so the children are only pruned once everything else the
+        # migration did to their parents has been undone
+        def sync_inheritance_features(*args, &block)
+          return record(:sync_inheritance_features, args, &block) unless reverting
+
+          commands.unshift(inverse_of(:sync_inheritance_features, args, &block))
+        end
+        ruby2_keywords(:sync_inheritance_features)
+
+        # Inverts the spread of features by running it again while pruning, so
+        # the children converge back to whatever the parent looks like
+        def invert_sync_inheritance_features(args)
+          options = args.extract_options!.merge(prune: true)
+          [:sync_inheritance_features, [*args, Hash.ruby2_keywords_hash(options)]]
+        end
+
         # Records the creation of a schema
         def create_schema(*args, &block)
           record(:create_schema, args, &block)

data/lib/torque/postgresql/predicate_builder/arel_attribute_handler.rb

@@ -25,7 +25,7 @@ module Torque
         private
 
           def array_typed?(attribute)
-            attribute.able_to_type_cast? && attribute.type_caster.is_a?(ARRAY_OID)
+            attribute.able_to_type_cast? && Adapter::OID.unwrap(attribute.type_caster).is_a?(ARRAY_OID)
           end
       end
     end

data/lib/torque/postgresql/predicate_builder/array_handler.rb

@@ -12,13 +12,17 @@ module Torque
         end
 
         def call_for_array(attribute, value)
-          if !value.is_a?(::Array)
-            call_with_value(attribute, value)
-          elsif value.any?
-            call_with_array(attribute, value)
-          else
-            call_with_empty(attribute)
-          end
+          return attribute.eq(nil) if value.nil?
+
+          value = value.to_a if value.is_a?(::Set)
+          return call_with_value(attribute, value) unless value.is_a?(::Array)
+          return call_with_empty(attribute) if value.empty?
+
+          nils, values = value.map { |entry| id_of(entry) }.partition(&:nil?)
+          return attribute.eq(nil) if values.empty?
+
+          condition = call_with_array(attribute, values)
+          nils.empty? ? condition : condition.or(attribute.eq(nil))
         end
 
         private
@@ -35,8 +39,12 @@ module Torque
             FN.cardinality(attribute).eq(0)
           end
 
+          def id_of(entry)
+            entry.is_a?(::ActiveRecord::Base) ? entry.id : entry
+          end
+
           def array_attribute?(attribute)
-            attribute.type_caster.is_a?(ARRAY_OID)
+            Adapter::OID.unwrap(attribute.type_caster).is_a?(ARRAY_OID)
           end
       end
 

data/lib/torque/postgresql/predicate_builder/composite_handler.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      # Turns a hash of columns into a proper set of conditions over a composite
+      # column, handing each of them back to the predicate builder so that the
+      # whole +where+ vocabulary works inside a composite
+      class CompositeHandler
+        class << self
+          # Values that this handler knows how to deal with. Without a value,
+          # only a single composite has parts that can be reached on their own
+          def candidate?(type, value = nil)
+            return false unless Adapter::OID::Composite.from(type)
+            return !type.is_a?(ARRAY_OID) if value.nil?
+
+            case value
+            when ::Hash, Attributes::Composite then true
+            when ::Array then value.compact.any? { |entry| candidate?(type, entry) }
+            else false
+            end
+          end
+
+          # Whether the value describes columns, instead of whole records
+          def columns?(value)
+            value.is_a?(::Hash) || (value.is_a?(::Array) && value.all?(::Hash))
+          end
+        end
+
+        def initialize(predicate_builder)
+          @predicate_builder = predicate_builder
+        end
+
+        def call(attribute, type, value)
+          @composite = Adapter::OID::Composite.from(type)
+          array = type.is_a?(ARRAY_OID)
+          record = !self.class.columns?(value)
+
+          return call_for_record(attribute, value, array) if record
+          return call_for_array(attribute, value) if array
+
+          conditions_for(attribute, value)
+        end
+
+        # The columns of the composite value as the columns of a table, so that
+        # any of them can be resolved by name
+        def table_for(source, type)
+          @composite = Adapter::OID::Composite.from(type)
+          PredicateTable.new(self, source, Arel::Nodes::Column)
+        end
+
+        # The type of a single column of the composite type
+        def type_of(name)
+          columns = @composite.columns
+          name = name.to_s
+
+          raise ArgumentError, <<~MSG.squish unless columns.key?(name)
+            Unable to build a condition for "#{name}" because it is not a
+            column of the "#{@composite.name}" composite type.
+          MSG
+
+          [columns[name]]
+        end
+
+        private
+
+          attr_reader :predicate_builder, :composite
+
+          # Whole records cannot be sent as anonymous binds, because the
+          # comparison operators resolve them to the +record+ pseudo type, so
+          # they are always casted to the type they belong to
+          def call_for_record(attribute, value, array)
+            name = attribute.name
+            cast = composite.name
+
+            if !array && value.is_a?(::Array)
+              records = value.map { |entry| FN.bind(name, entry, composite).pg_cast(cast) }
+              return attribute.in(records)
+            end
+
+            return attribute.eq(FN.bind(name, value, composite).pg_cast(cast)) unless array
+
+            if value.is_a?(::Array)
+              list = FN.bind(name, value, ARRAY_OID.new(composite))
+              return attribute.overlaps(list.pg_cast(cast, true))
+            end
+
+            entry = FN.bind(name, value, composite).pg_cast(cast)
+            FN.infix(:"=", entry, FN.any(attribute))
+          end
+
+          # Entries of an array of composite values can only be matched one by
+          # one, so the conditions are checked against each unnested entry
+          def call_for_array(attribute, value)
+            source = Arel::Nodes::Ref.new(composite.name)
+            entries = ::Arel::Nodes::TableAlias.new(FN.unnest(attribute), composite.name)
+
+            manager = ::Arel::SelectManager.new
+            manager.from(entries)
+            manager.project(::Arel.sql('1'))
+            manager.where(conditions_for(source, value))
+            manager.exists
+          end
+
+          # A list of values means that any of them is a match
+          def conditions_for(source, value)
+            return group_for(source, value) unless value.is_a?(::Array)
+
+            groups = value.map { |entry| group_for(source, entry) }
+            groups.reduce(:or)
+          end
+
+          def group_for(source, entry)
+            entry = entry.to_h unless entry.is_a?(::Hash)
+            table = table_for(source, composite)
+            nodes = predicate_builder.with(table).build_from_hash(entry.stringify_keys)
+            ::Arel::Nodes::Grouping.new(nodes.reduce(:and))
+          end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/predicate_builder/ltree_handler.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      # Serves every column of the ltree extension. A value of the same kind as
+      # the column is an equality, a value of the opposite kind is a match, and
+      # an Array is a list of values as soon as its first entry is a whole one
+      class LtreeHandler
+        class << self
+          def candidate?(type)
+            column_of(type).is_a?(Adapter::OID::Ltree)
+          end
+
+          def column_of(type)
+            type.is_a?(ARRAY_OID) ? type.subtype : type
+          end
+        end
+
+        def initialize(predicate_builder)
+          @predicate_builder = predicate_builder
+        end
+
+        def call(attribute, type, value)
+          @attribute = attribute
+          @column = self.class.column_of(type)
+          @array = type.is_a?(ARRAY_OID)
+          @list = list?(value)
+
+          values = list ? value : [value]
+          pattern = values.any? { |entry| lquery.cast(entry)&.pattern? }
+          pattern == lquery_column? ? equality(values) : match(values)
+        end
+
+        private
+
+          attr_reader :attribute, :column, :array, :list
+
+          def list?(value)
+            return false unless value.is_a?(::Array)
+
+            first = value.first
+            value.empty? || first.is_a?(::Array) || first.is_a?(LTree) || first.is_a?(LQuery)
+          end
+
+          def lquery_column?
+            column.is_a?(Adapter::OID::Lquery)
+          end
+
+          def lquery
+            Adapter::OID::Lquery.new
+          end
+
+          def ltree
+            Adapter::OID::Ltree.new
+          end
+
+          # Bound as the value the type produces, since Rails deep dups a raw
+          # value before compiling the query, and a dup of a record has no id
+          def bind(value, type)
+            FN.bind(attribute.name, type.cast(value), type)
+          end
+
+          # PostgreSQL defines no equality operator for lquery, so a pattern
+          # column is compared by its text form
+          def equality(values)
+            target = lquery_column? ? attribute.pg_cast('text', array) : attribute
+            return single_equality(target, bind(values.first, column)) unless list
+            return empty_equality(target) if values.empty?
+            return target.overlaps(bind(values, ARRAY_OID.new(column))) if array
+
+            binds = values.map { |entry| bind(entry, column) }
+            target.in(binds)
+          end
+
+          def single_equality(target, bind)
+            return target.eq(bind) unless array
+
+            FN.infix(:"=", bind, FN.any(target))
+          end
+
+          def empty_equality(target)
+            return target.in([]) unless array
+
+            FN.cardinality(attribute).eq(0)
+          end
+
+          def match(values)
+            other = lquery_column? ? ltree : lquery
+            cast = other.type.to_s
+            return single_match(bind(values.first, other).pg_cast(cast)) unless list
+
+            list_match(bind(values, ARRAY_OID.new(other)).pg_cast(cast, true))
+          end
+
+          # PostgreSQL defines ~ for every pair except lquery[] against ltree
+          def single_match(bind)
+            return attribute.matches_lquery(bind) unless array && lquery_column?
+
+            FN.infix(:"~", bind, FN.any(attribute))
+          end
+
+          # PostgreSQL defines ? for every pair except lquery against ltree[]
+          def list_match(binds)
+            return attribute.matches_any_lquery(binds) if array || !lquery_column?
+
+            FN.infix(:"~", attribute, FN.any(binds))
+          end
+      end
+    end
+  end
+end