torque-postgresql 4.0.1 → 4.1.1

data/lib/torque/postgresql/base.rb

@@ -17,8 +17,31 @@ module Torque
       end
 
       class_methods do
-        delegate :distinct_on, :with, :itself_only, :cast_records, :join_series,
-          :buckets, to: :all
+        delegate :distinct_on, :with, :itself_only, :expand_records, :join_series,
+          :buckets, :segments, to: :all
+
+        # The Arel node for a path into a document column, typed by the struct
+        # class that backs the column when there is one
+        def arel_property_of(column, *path)
+          type = Adapter::OID.unwrap(attribute_types[column.to_s])
+          handler = PredicateBuilder::StructHandler.new(predicate_builder)
+          handler.property_for(arel_table[column], type, path)
+        end
+
+        # Composite values are objects that can be invalid on their own, so the
+        # attributes backed by one are validated alongside the record
+        def load_schema!
+          super
+          return unless PostgreSQL.config.composite.enabled &&
+            Adapter::OID.const_defined?(:Composite)
+
+          attribute_types.each do |name, type|
+            next if Adapter::OID::Composite.from(type).nil?
+            next if _validators[name.to_sym].any?(Validations::NestedValidator)
+
+            validates(name, nested: true)
+          end
+        end
 
         # Make sure that table name is an instance of TableName class
         def reset_table_name
@@ -27,24 +50,12 @@ module Torque
         end
 
         # Whenever the base model is inherited, add a list of auxiliary
-        # statements like the one that loads inherited records' relname
+        # statements
         def inherited(subclass)
           super
 
           subclass.class_attribute(:auxiliary_statements_list)
           subclass.auxiliary_statements_list = {}
-
-          record_class = ActiveRecord::Relation._record_class_attribute
-
-          # Define the dynamic attribute that returns the same information as
-          # the one provided by the auxiliary statement
-          subclass.dynamic_attribute(record_class) do
-            klass = self.class
-            next klass.table_name unless klass.physically_inheritances?
-
-            query = klass.unscoped.where(subclass.primary_key => id)
-            query.pluck(klass.arel_table['tableoid'].pg_cast('regclass')).first
-          end
         end
 
         # Specifies a one-to-many association. The following methods for

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
@@ -28,10 +38,13 @@ module Torque
     # Add support for querying and calculating histogram buckets
     config.buckets = true
 
+    # Add support for segmenting calculations by named conditions
+    config.segments = true
+
     # 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 +144,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 +206,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 +305,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 is sent to the database, 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 +347,8 @@ module Torque
         'doesnt_right_extend' => '&<',
         'doesnt_left_extend'  => '&>',
         'adjacent_to'         => '-|-',
+        'matches_lquery'      => '~',
+        'matches_any_lquery'  => '?',
       }
 
     end
@@ -344,7 +414,7 @@ module Torque
 
       # Define the list of commands that are going to be versioned by this
       # method
-      vs.types = %i[function type view]
+      vs.types = %i[function type view trigger]
 
       # The name of the table that will inherit from +schema_migrations+ and
       # store the list of versioned commands that have been executed
@@ -352,5 +422,20 @@ module Torque
 
     end
 
+    # Configure cross join features
+    config.nested(:cross_join) do |cross_join|
+
+      # This is an experimental feature that developers must explicitly opt-in.
+      # TODO: hook into how conditions and columns are resolved, so that the
+      # name of a joined set can shadow a real column
+      cross_join.enabled = false
+
+      # The name of the column added by +with_ordinality+ when it is given
+      # +true+ instead of a name. It matches what PostgreSQL calls the column
+      # when it is not named at all
+      cross_join.ordinality_column = :ordinality
+
+    end
+
   end
 end

data/lib/torque/postgresql/geometry_builder.rb

@@ -24,8 +24,7 @@ module Torque
         case value
         when ::String
           return if value.blank?
-          value.gsub!(DESTRUCTOR, '')
-          build_klass(*value.split(','))
+          build_klass(*value.gsub(DESTRUCTOR, '').split(','))
         when ::Hash
           build_klass(*value.symbolize_keys.slice(*pieces).values)
         when ::Array
@@ -49,8 +48,8 @@ module Torque
         parts = parts&.compact&.flatten
         return if parts.blank?
 
-        raise 'Invalid format' if parts.size < pieces.size
-        format(formation, *parts.first(pieces.size).map(&number_serializer))
+        parts = ::Array.new(pieces.size) { |index| parts[index] }
+        format(formation, *parts.map(&number_serializer))
       end
 
       def deserialize(value)
@@ -81,13 +80,8 @@ module Torque
 
         def build_klass(*args)
           return nil if args.empty?
-          check_invalid_format!(args)
 
-          config_class.new(*args.try(:first, pieces.size)&.map(&:to_f))
-        end
-
-        def check_invalid_format!(args)
-          raise 'Invalid format' if args.size < pieces.size
+          config_class.new(*args.first(pieces.size).map(&:to_f))
         end
     end
   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