torque-postgresql 4.0.0 → 4.1.0

data/lib/torque/postgresql/config.rb

@@ -2,19 +2,29 @@
 
 module Torque
   module PostgreSQL
-    include ActiveSupport::Configurable
+    # Stores a version check for compatibility purposes
+    AR810 = (ActiveRecord.gem_version >= Gem::Version.new('8.1.0'))
 
-    # Use the same logger as the Active Record one
-    def self.logger
-      ActiveRecord::Base.logger
+    class << self
+      def config
+        @config ||= ActiveSupport::InheritableOptions.new
+      end
+
+      def configure
+        yield config
+      end
+
+      # Use the same logger as the Active Record one
+      def logger
+        ActiveRecord::Base.logger
+      end
     end
 
     # Allow nested configurations
-    # :TODO: Rely on +inheritable_copy+ to make nested configurations
     config.define_singleton_method(:nested) do |name, &block|
-      klass = Class.new(ActiveSupport::Configurable::Configuration).new
-      block.call(klass) if block
-      send("#{name}=", klass)
+      nested = ActiveSupport::InheritableOptions.new
+      block&.call(nested)
+      self[name] = nested
     end
 
     # Set if any information that requires querying and searching or collecting
@@ -31,7 +41,7 @@ module Torque
     # Set a list of irregular model name when associated with table names
     config.irregular_models = {}
     def config.irregular_models=(hash)
-      PostgreSQL.config[:irregular_models] = hash.map do |(table, model)|
+      self[:irregular_models] = hash.map do |(table, model)|
         [table.to_s, model.to_s]
       end.to_h
     end
@@ -131,6 +141,27 @@ module Torque
 
     end
 
+    # Configure composite type features
+    config.nested(:composite) do |composite|
+
+      # Enables composite types handler by this gem
+      composite.enabled = true
+
+      # Specify the namespace of each composite type class
+      composite.namespace = nil
+
+      # Set a list of irregular class names when associated with composite
+      # types
+      def composite.irregular_types=(hash)
+        self[:irregular_types] = hash.map do |type, klass|
+          [type.to_s, klass.to_s]
+        end.to_h
+      end
+
+      composite.irregular_types = {}
+
+    end
+
     # Configure geometry data types
     config.nested(:geometry) do |geometry|
 
@@ -172,10 +203,21 @@ module Torque
       # the name of the table that actually holds the record
       inheritance.record_class_column_name = :_record_class
 
-      # Determines the name of the column used when identifying that the loaded
-      # records should be casted to its correctly model. This will be TRUE for
-      # the records mentioned on `cast_records`
-      inheritance.auto_cast_column_name = :_auto_cast
+    end
+
+    # Configure struct features
+    config.nested(:struct) do |struct|
+
+      # Enables the JSON(B) columns backed by ActiveModel classes handler
+      struct.enabled = true
+
+      # The name of the method to be used on any ActiveRecord::Base to
+      # initialize model-based struct features
+      struct.base_method = :struct_for
+
+      # Whether struct classes reject properties that they don't declare
+      # by default
+      struct.default_strict = true
 
     end
 
@@ -260,12 +302,35 @@ module Torque
 
     end
 
+    # Configure label tree features
+    config.nested(:ltree) do |ltree|
+
+      # Enables the ltree and lquery data types handler by this gem
+      ltree.enabled = true
+
+      # A hash of replacements applied to every label provided by the
+      # application before it gets validated, so that a source that does not
+      # satisfy PostgreSQL's rules on its own can still be used. Dashes, for
+      # example, are only accepted as of PostgreSQL 16
+      #   { '-' => '_' } turns dashes into underscores
+      #   { '-' => '' }  drops dashes
+      # It never applies to values read from the database
+      ltree.sanitize = nil
+
+      # The name of a method that, whenever the given object responds to it, is
+      # used to translate that object into a path or a pattern. It is what lets
+      # any class be used wherever one is expected, on assignment, on a
+      # condition, and while comparing one path to another
+      ltree.compatible_method = :to_tree_path
+
+    end
+
     # Configure arel additional features
     config.nested(:arel) do |arel|
 
       # When provided, the initializer will expose the Arel function helper on
       # the given module
-      config.expose_function_helper_on = nil
+      arel.expose_function_helper_on = nil
 
       # List of Arel INFIX operators that will be made available for using as
       # methods on Arel::Nodes::Node and Arel::Attribute
@@ -279,6 +344,8 @@ module Torque
         'doesnt_right_extend' => '&<',
         'doesnt_left_extend'  => '&>',
         'adjacent_to'         => '-|-',
+        'matches_lquery'      => '~',
+        'matches_any_lquery'  => '?',
       }
 
     end

data/lib/torque/postgresql/inheritance/expander.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Inheritance
+      class Expander
+
+        def initialize(model, records, targets)
+          @model = model
+          @records = records
+          @targets = targets
+        end
+
+        # Load the columns that are missing from each partial record using one
+        # query per inherited table
+        def call
+          pending.each do |klass, records|
+            amend(klass, records, fetch(klass, records.map(&:id)))
+          end
+
+          @records
+        end
+
+        private
+
+          attr_reader :model, :targets
+
+          def pending
+            @records.select do |record|
+              record.partial_record? && targets.include?(record.class)
+            end.group_by(&:class)
+          end
+
+          def extra_columns(klass)
+            klass.attribute_names - model.attribute_names
+          end
+
+          def fetch(klass, ids)
+            columns = [klass.primary_key, *extra_columns(klass)]
+            table = klass.arel_table
+            query = klass.unscoped.itself_only.select(*columns.map { |name| table[name] })
+
+            klass.lease_connection.select_all(
+              query.where(klass.primary_key => ids).arel,
+              "#{klass.name} Expand",
+            ).to_a.index_by { |row| row[klass.primary_key] }
+          end
+
+          def amend(klass, records, rows)
+            columns = extra_columns(klass)
+
+            records.each do |record|
+              row = rows[record.id]
+              next if row.nil?
+
+              attributes = record.instance_variable_get(:@attributes)
+              columns.each { |name| attributes.write_from_database(name, row[name]) }
+
+              record.send(:mark_as_full_record!)
+            end
+          end
+
+      end
+    end
+  end
+end

data/lib/torque/postgresql/inheritance/record.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Inheritance
+      module Record
+
+        # Whether the record was loaded from one of its ancestor tables and
+        # therefore is missing the columns that only exist on its own table
+        def partial_record?
+          @partial_record == true
+        end
+
+        # Reload always queries the record's own table, which produces a
+        # complete and writable record
+        def reload(*)
+          return super unless partial_record?
+
+          super.tap { mark_as_full_record! }
+        end
+
+        # Deleting a row only needs its primary key, so the missing columns of
+        # a partial record are no reason to refuse it
+        def destroy
+          return super unless partial_record?
+
+          without_readonly { super }
+        end
+
+        private
+
+          def without_readonly
+            @readonly = false
+            yield
+          ensure
+            @readonly = true
+          end
+
+          def mark_as_partial_record!
+            @partial_record = true
+            readonly!
+          end
+
+          def mark_as_full_record!
+            @partial_record = false
+            @readonly = false
+          end
+
+      end
+    end
+  end
+end

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.schema_cache.dependencies(
+              defined?(@table_name) ? @table_name : decorated_table_name,
+            ).present?
+          end
         rescue ActiveRecord::ConnectionNotEstablished
           false
         end
@@ -71,15 +61,58 @@ module Torque
 
         # 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.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
@@ -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)