torque-postgresql 2.4.2 → 3.0.0

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

@@ -11,8 +11,61 @@ module Torque
           # For reflections connected through an array, make sure to properly
           # decuple the list of ids and set them as associated with the owner
           def run
+            return self if run?
             return super unless connected_through_array?
+
+            @run = true
             send("run_array_for_#{@reflection.macro}")
+            self
+          end
+
+          # Correctly correlate records when they are connected theough an array
+          def set_inverse(record)
+            return super unless connected_through_array? && @reflection.macro == :has_many
+
+            # Only the first owner is associated following the same instruction
+            # on the original implementation
+            convert_key(record[association_key_name])&.each do |key|
+              if owners = owners_by_key[key]
+                association = owners.first.association(reflection.name)
+                association.set_inverse_instance(record)
+              end
+            end
+          end
+
+          # Requires a slight change when running on has many since the value
+          # of the foreign key being an array
+          def load_records(raw_records = nil)
+            return super unless connected_through_array? && @reflection.macro == :has_many
+
+            @records_by_owner = {}.compare_by_identity
+            raw_records ||= loader_query.records_for([self])
+
+            @preloaded_records = raw_records.select do |record|
+              assignments = false
+
+              keys = convert_key(record[association_key_name]) || []
+              owners_by_key.values_at(*keys).each do |owner|
+                entries = (@records_by_owner[owner] ||= [])
+
+                if reflection.collection? || entries.empty?
+                  entries << record
+                  assignments = true
+                end
+              end
+
+              assignments
+            end
+          end
+
+          # Make sure to change the process when connected through an array
+          def owners_by_key
+            return super unless connected_through_array?
+            @owners_by_key ||= owners.each_with_object({}) do |owner, result|
+              Array.wrap(convert_key(owner[owner_key_name])).each do |key|
+                (result[key] ||= []) << owner
+              end
+            end
           end
 
           private
@@ -41,32 +94,6 @@ module Torque
               end
             end
 
-            if PostgreSQL::AR604
-            # This is how Rails 6.0.4 and 6.1 now load the records
-              def load_records
-                return super unless connected_through_array?
-
-                @records_by_owner = {}.compare_by_identity
-                raw_records = owner_keys.empty? ? [] : records_for(owner_keys)
-
-                @preloaded_records = raw_records.select do |record|
-                  assignments = false
-
-                  ids = convert_key(record[association_key_name])
-                  owners_by_key.values_at(*ids).flat_map do |owner|
-                    entries = (@records_by_owner[owner] ||= [])
-
-                    if reflection.collection? || entries.empty?
-                      entries << record
-                      assignments = true
-                    end
-                  end
-
-                  assignments
-                end
-              end
-            end
-
             # Build correctly the constraint condition in order to get the
             # associated ids
             def records_for(ids, &block)

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Associations
+      module Preloader
+        module LoaderQuery
+          def foreign_column
+            @foreign_column ||= scope.columns_hash[association_key_name]
+          end
+
+          def load_records_for_keys(keys, &block)
+            condition = query_condition_for(keys)
+            scope.where(condition).load(&block)
+          end
+
+          def query_condition_for(keys)
+            if connected_through_array?
+              value = scope.cast_for_condition(foreign_column, keys.to_a)
+              scope.table[association_key_name].overlaps(value)
+            else
+              { association_key_name => keys }
+            end
+          end
+
+          def connected_through_array?
+            foreign_column.array?
+          end
+        end
+
+        ::ActiveRecord::Associations::Preloader::Association::LoaderQuery
+          .prepend(LoaderQuery)
+      end
+    end
+  end
+end

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

@@ -1 +1,2 @@
 require_relative 'preloader/association'
+require_relative 'preloader/loader_query'

data/lib/torque/postgresql/associations.rb

@@ -1,5 +1,10 @@
-require_relative 'associations/association'
 require_relative 'associations/association_scope'
 require_relative 'associations/belongs_to_many_association'
+require_relative 'associations/foreign_association'
+
 require_relative 'associations/builder'
 require_relative 'associations/preloader'
+
+association_mod = Torque::PostgreSQL::Associations::ForeignAssociation
+::ActiveRecord::Associations::HasManyAssociation.prepend(association_mod)
+::ActiveRecord::Associations::BelongsToManyAssociation.prepend(association_mod)

data/lib/torque/postgresql/attributes/builder/period.rb

@@ -220,7 +220,7 @@ module Torque
               @arel_threshold_value ||= begin
                 case threshold
                 when Symbol, String
-                  "arel_attribute('#{threshold}')"
+                  "arel_table['#{threshold}']"
                 when ActiveSupport::Duration
                   value = "'#{threshold.to_i} seconds'"
                   "::Arel.sql(\"#{value}\").cast(:interval)"
@@ -453,7 +453,11 @@ module Torque
               attr_value = threshold.present? ? method_names[:real] : attribute
               default_value = default.inspect
 
-              "#{attr_value}.nil? ? #{default_value} : #{attr_value}.include?(value)"
+              [
+                "return #{default_value} if #{attr_value}.nil?",
+                "(#{attr_value}.min.try(:infinite?) || #{attr_value}.min <= value) &&",
+                "  (#{attr_value}.max.try(:infinite?) || #{attr_value}.max > value)",
+              ].join("\n")
             end
 
             def instance_start

data/lib/torque/postgresql/auxiliary_statement/settings.rb

@@ -4,9 +4,9 @@ module Torque
   module PostgreSQL
     class AuxiliaryStatement
       class Settings < Collector.new(:attributes, :join, :join_type, :query, :requires,
-          :polymorphic, :through, :union_all, :connect)
+          :polymorphic, :through)
 
-        attr_reader :base, :source, :depth, :path
+        attr_reader :base, :source
         alias_method :select, :attributes
         alias_method :cte, :source
 
@@ -14,10 +14,9 @@ module Torque
         delegate :table, :table_name, to: :@source
         delegate :sql, to: ::Arel
 
-        def initialize(base, source, recursive = false)
+        def initialize(base, source)
           @base = base
           @source = source
-          @recursive = recursive
         end
 
         def base_name
@@ -28,39 +27,6 @@ module Torque
           @base.arel_table
         end
 
-
-        def recursive?
-          @recursive
-        end
-
-        def depth?
-          defined?(@depth)
-        end
-
-        def path?
-          defined?(@path)
-        end
-
-        # Add an attribute to the result showing the depth of each iteration
-        def with_depth(name = 'depth', start: 0, as: nil)
-          @depth = [name.to_s, start, as&.to_s] if recursive?
-        end
-
-        # Add an attribute to the result showing the path of each record
-        def with_path(name = 'path', source: nil, as: nil)
-          @path = [name.to_s, source&.to_s, as&.to_s] if recursive?
-        end
-
-        # Set recursive operation to use union all
-        def union_all!
-          @union_all = true if recursive?
-        end
-
-        # Add both depth and path to the result
-        def with_depth_and_path
-          with_depth && with_path
-        end
-
         # Get the arel version of the table set on the query
         def query_table
           raise StandardError, 'The query is not defined yet' if query.nil?
@@ -75,55 +41,36 @@ module Torque
 
         alias column col
 
-        # There are three ways of setting the query:
+        # There are two ways of setting the query:
         # - A simple relation based on a Model
         # - A Arel-based select manager
-        # - A string or a proc
+        # - A string or a proc that requires the table name as first argument
         def query(value = nil, command = nil)
           return @query if value.nil?
+          return @query = value if relation_query?(value)
 
-          @query = sanitize_query(value, command)
-        end
-
-        # Same as query, but for the second part of the union for recursive cte
-        def sub_query(value = nil, command = nil)
-          return unless recursive?
-          return @sub_query if value.nil?
+          if value.is_a?(::Arel::SelectManager)
+            @query = value
+            @query_table = value.source.left.name
+            return
+          end
 
-          @sub_query = sanitize_query(value, command)
-        end
+          valid_type = command.respond_to?(:call) || command.is_a?(String)
 
-        # Assume `parent_` as the other part if provided a Symbol or String
-        def connect(value = nil)
-          return @connect if value.nil?
+          raise ArgumentError, <<-MSG.squish if command.nil?
+            To use proc or string as query, you need to provide the table name
+            as the first argument
+          MSG
 
-          value = [value.to_sym, :"parent_#{value}"] \
-            if value.is_a?(String) || value.is_a?(Symbol)
-          value = value.to_a.first if value.is_a?(Hash)
+          raise ArgumentError, <<-MSG.squish unless valid_type
+            Only relation, string and proc are valid object types for query,
+            #{command.inspect} given.
+          MSG
 
-          @connect = value
+          @query = command
+          @query_table = ::Arel::Table.new(value)
         end
 
-        alias connect= connect
-
-        private
-
-          # Get the query and table from the params
-          def sanitize_query(value, command = nil)
-            return value if relation_query?(value)
-            return value if value.is_a?(::Arel::SelectManager)
-
-            command = value if command.nil? # For compatibility purposes
-            valid_type = command.respond_to?(:call) || command.is_a?(String)
-
-            raise ArgumentError, <<-MSG.squish unless valid_type
-              Only relation, string and proc are valid object types for query,
-              #{command.inspect} given.
-            MSG
-
-            command
-          end
-
       end
     end
   end

data/lib/torque/postgresql/auxiliary_statement.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'auxiliary_statement/settings'
-require_relative 'auxiliary_statement/recursive'
 
 module Torque
   module PostgreSQL
@@ -9,20 +8,17 @@ module Torque
       TABLE_COLUMN_AS_STRING = /\A(?:"?(\w+)"?\.)?"?(\w+)"?\z/.freeze
 
       class << self
-        attr_reader :config, :table_name
+        attr_reader :config
 
         # Find or create the class that will handle statement
         def lookup(name, base)
           const = name.to_s.camelize << '_' << self.name.demodulize
           return base.const_get(const, false) if base.const_defined?(const, false)
-
-          base.const_set(const, Class.new(self)).tap do |klass|
-            klass.instance_variable_set(:@table_name, name.to_s)
-          end
+          base.const_set(const, Class.new(AuxiliaryStatement))
         end
 
         # Create a new instance of an auxiliary statement
-        def instantiate(statement, base, **options)
+        def instantiate(statement, base, options = nil)
           klass = while base < ActiveRecord::Base
             list = base.auxiliary_statements_list
             break list[statement] if list.present? && list.key?(statement)
@@ -30,15 +26,15 @@ module Torque
             base = base.superclass
           end
 
-          return klass.new(**options) unless klass.nil?
+          return klass.new(options) unless klass.nil?
           raise ArgumentError, <<-MSG.squish
             There's no '#{statement}' auxiliary statement defined for #{base.class.name}.
           MSG
         end
 
         # Fast access to statement build
-        def build(statement, base, bound_attributes = [], join_sources = [], **options)
-          klass = instantiate(statement, base, **options)
+        def build(statement, base, options = nil, bound_attributes = [], join_sources = [])
+          klass = instantiate(statement, base, options)
           result = klass.build(base)
 
           bound_attributes.concat(klass.bound_attributes)
@@ -60,7 +56,7 @@ module Torque
         # A way to create auxiliary statements outside of models configurations,
         # being able to use on extensions
         def create(table_or_settings, &block)
-          klass = Class.new(self)
+          klass = Class.new(AuxiliaryStatement)
 
           if block_given?
             klass.instance_variable_set(:@table_name, table_or_settings)
@@ -93,8 +89,7 @@ module Torque
         def configure(base, instance)
           return @config unless @config.respond_to?(:call)
 
-          recursive = self < AuxiliaryStatement::Recursive
-          settings = Settings.new(base, instance, recursive)
+          settings = Settings.new(base, instance)
           settings.instance_exec(settings, &@config)
           settings
         end
@@ -103,6 +98,11 @@ module Torque
         def table
           @table ||= ::Arel::Table.new(table_name)
         end
+
+        # Get the name of the table of the configurated statement
+        def table_name
+          @table_name ||= self.name.demodulize.split('_').first.underscore
+        end
       end
 
       delegate :config, :table, :table_name, :relation, :configure, :relation_query?,
@@ -111,14 +111,15 @@ module Torque
       attr_reader :bound_attributes, :join_sources
 
       # Start a new auxiliary statement giving extra options
-      def initialize(*, **options)
+      def initialize(*args)
+        options = args.extract_options!
         args_key = Torque::PostgreSQL.config.auxiliary_statement.send_arguments_key
 
         @join = options.fetch(:join, {})
         @args = options.fetch(args_key, {})
         @where = options.fetch(:where, {})
         @select = options.fetch(:select, {})
-        @join_type = options[:join_type]
+        @join_type = options.fetch(:join_type, nil)
 
         @bound_attributes = []
         @join_sources = []
@@ -130,7 +131,7 @@ module Torque
         @join_sources.clear
 
         # Prepare all the data for the statement
-        prepare(base, configure(base, self))
+        prepare(base)
 
         # Add the join condition to the list
         @join_sources << build_join(base)
@@ -141,7 +142,8 @@ module Torque
 
       private
         # Setup the statement using the class configuration
-        def prepare(base, settings)
+        def prepare(base)
+          settings = configure(base, self)
           requires = Array.wrap(settings.requires).flatten.compact
           @dependencies = ensure_dependencies(requires, base).flatten.compact
 
@@ -149,13 +151,14 @@ module Torque
           @query = settings.query
 
           # Call a proc to get the real query
-          if @query.respond_to?(:call)
+          if @query.methods.include?(:call)
             call_args = @query.try(:arity) === 0 ? [] : [OpenStruct.new(@args)]
             @query = @query.call(*call_args)
             @args = []
           end
 
-          # Merge select attributes provided on the instance creation
+          # Manually set the query table when it's not an relation query
+          @query_table = settings.query_table unless relation_query?(@query)
           @select = settings.attributes.merge(@select) if settings.attributes.present?
 
           # Merge join settings
@@ -165,7 +168,7 @@ module Torque
             @association = settings.through.to_s
           elsif relation_query?(@query)
             @association = base.reflections.find do |name, reflection|
-              break name if @query.klass.eql?(reflection.klass)
+              break name if @query.klass.eql? reflection.klass
             end
           end
         end
@@ -231,6 +234,15 @@ module Torque
             as a query object on #{self.class.name}.
           MSG
 
+          # Expose join columns
+          if relation_query?(@query)
+            query_table = @query.arel_table
+            conditions.children.each do |item|
+              @query.select_values += [query_table[item.left.name]] \
+                if item.left.relation.eql?(table)
+            end
+          end
+
           # Build the join based on the join type
           arel_join.new(table, table.create_on(conditions))
         end
@@ -251,31 +263,21 @@ module Torque
 
         # Mount the list of selected attributes
         def expose_columns(base, query_table = nil)
-          # Add the columns necessary for the join
-          list = @join_sources.each_with_object(@select) do |join, hash|
-            join.right.expr.children.each do |item|
-              hash[item.left.name] = nil if item.left.relation.eql?(table)
-            end
-          end
-
           # Add select columns to the query and get exposed columns
-          list.map do |left, right|
-            base.select_extra_values += [table[right.to_s]] unless right.nil?
-            next unless query_table
-
-            col = project(left, query_table)
-            right.nil? ? col : col.as(right.to_s)
-          end.compact
+          @select.map do |left, right|
+            base.select_extra_values += [table[right.to_s]]
+            project(left, query_table).as(right.to_s) if query_table
+          end
         end
 
         # Ensure that all the dependencies are loaded in the base relation
         def ensure_dependencies(list, base)
           with_options = list.extract_options!.to_a
-          (list + with_options).map do |name, options|
-            dependent_klass = base.model.auxiliary_statements_list[name]
+          (list + with_options).map do |dependent, options|
+            dependent_klass = base.model.auxiliary_statements_list[dependent]
 
             raise ArgumentError, <<-MSG.squish if dependent_klass.nil?
-              The '#{name}' auxiliary statement dependency can't found on
+              The '#{dependent}' auxiliary statement dependency can't found on
               #{self.class.name}.
             MSG
 
@@ -283,8 +285,7 @@ module Torque
               cte.is_a?(dependent_klass)
             end
 
-            options ||= {}
-            AuxiliaryStatement.build(name, base, bound_attributes, join_sources, **options)
+            AuxiliaryStatement.build(dependent, base, options, bound_attributes, join_sources)
           end
         end
 

data/lib/torque/postgresql/base.rb

@@ -5,27 +5,15 @@ module Torque
     module Base
       extend ActiveSupport::Concern
 
-      ##
-      # :singleton-method: schema
-      # :call-seq: schema
-      #
-      # The schema to which the table belongs to.
-
       included do
         mattr_accessor :belongs_to_many_required_by_default, instance_accessor: false
-        class_attribute :schema, instance_writer: false
       end
 
       module ClassMethods
         delegate :distinct_on, :with, :itself_only, :cast_records, to: :all
 
-        # Make sure that table name is an instance of TableName class
-        def reset_table_name
-          self.table_name = TableName.new(self, super)
-        end
-
-        # Whenever the base model is inherited, add a list of auxiliary
-        # statements like the one that loads inherited records' relname
+        # Wenever it's inherited, add a new list of auxiliary statements
+        # It also adds an auxiliary statement to load inherited records' relname
         def inherited(subclass)
           super
 
@@ -36,11 +24,6 @@ module Torque
 
           # Define helper methods to return the class of the given records
           subclass.auxiliary_statement record_class do |cte|
-            ActiveSupport::Deprecation.warn(<<~MSG.squish)
-              Inheritance does not use this auxiliary statement and it can be removed.
-              You can replace it with `model.select_extra_values << 'tableoid::regclass'`.
-            MSG
-
             pg_class = ::Arel::Table.new('pg_class')
             arel_query = ::Arel::SelectManager.new(pg_class)
             arel_query.project(pg_class['oid'], pg_class['relname'].as(record_class.to_s))
@@ -53,11 +36,18 @@ module Torque
           # 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?
+            next self.class.table_name unless self.class.physically_inheritances?
+
+            pg_class = ::Arel::Table.new('pg_class')
+            source = ::Arel::Table.new(subclass.table_name, as: 'source')
+            quoted_id = ::Arel::Nodes::Quoted.new(id)
 
-            query = klass.unscoped.where(subclass.primary_key => id)
-            query.pluck(klass.arel_table['tableoid'].cast('regclass')).first
+            query = ::Arel::SelectManager.new(pg_class)
+            query.join(source).on(pg_class['oid'].eq(source['tableoid']))
+            query.where(source[subclass.primary_key].eq(quoted_id))
+            query.project(pg_class['relname'])
+
+            self.class.connection.select_value(query)
           end
         end
 
@@ -309,16 +299,6 @@ module Torque
             klass.configurator(block)
           end
           alias cte auxiliary_statement
-
-          # Creates a new recursive auxiliary statement (CTE) under the base
-          # Very similar to the regular auxiliary statement, but with two-part
-          # query where one is executed first and the second recursively
-          def recursive_auxiliary_statement(table, &block)
-            klass = AuxiliaryStatement::Recursive.lookup(table, self)
-            auxiliary_statements_list[table.to_sym] = klass
-            klass.configurator(block)
-          end
-          alias recursive_cte recursive_auxiliary_statement
       end
     end
 

data/lib/torque/postgresql/config.rb

@@ -4,11 +4,6 @@ module Torque
   module PostgreSQL
     include ActiveSupport::Configurable
 
-    # Stores a version check for compatibility purposes
-    AR604 = (ActiveRecord.gem_version >= Gem::Version.new('6.0.4'))
-    AR610 = (ActiveRecord.gem_version >= Gem::Version.new('6.1.0'))
-    AR615 = (ActiveRecord.gem_version >= Gem::Version.new('6.1.5'))
-
     # Use the same logger as the Active Record one
     def self.logger
       ActiveRecord::Base.logger
@@ -27,11 +22,6 @@ module Torque
     # same configuration is set to true
     config.eager_load = false
 
-    # This allows default values to have extended values like arrays and casted
-    # values. Extended defaults are still experimental, so enable and test it
-    # before using it in prod
-    config.use_extended_defaults = false
-
     # Set a list of irregular model name when associated with table names
     config.irregular_models = {}
     def config.irregular_models=(hash)
@@ -40,19 +30,6 @@ module Torque
       end.to_h
     end
 
-    # Configure multiple schemas
-    config.nested(:schemas) do |schemas|
-
-      # Defines a list of LIKE-based schemas to not consider for a multiple
-      # schema database
-      schemas.blacklist = %w[information_schema pg_%]
-
-      # Defines a list of LIKE-based schemas to consider for a multiple schema
-      # database
-      schemas.whitelist = %w[public]
-
-    end
-
     # Configure associations features
     config.nested(:associations) do |assoc|
 
@@ -69,14 +46,10 @@ module Torque
       # arguments to format string or send on a proc
       cte.send_arguments_key = :args
 
-      # Estipulate a class name (which may contain namespace) that exposes the
+      # Estipulate a class name (which may contain namespace) that expose the
       # auxiliary statement in order to perform detached CTEs
       cte.exposed_class = 'TorqueCTE'
 
-      # Estipulate a class name (which may contain namespace) that exposes the
-      # recursive auxiliary statement in order to perform detached CTEs
-      cte.exposed_recursive_class = 'TorqueRecursiveCTE'
-
     end
 
     # Configure ENUM features
@@ -84,11 +57,11 @@ module Torque
 
       # The name of the method to be used on any ActiveRecord::Base to
       # initialize model-based enum features
-      enum.base_method = :enum
+      enum.base_method = :torque_enum
 
       # The name of the method to be used on any ActiveRecord::Base to
       # initialize model-based enum set features
-      enum.set_method = :enum_set
+      enum.set_method = :torque_enum_set
 
       # Indicates if bang methods like 'disabled!' should update the record on
       # database or not

data/lib/torque/postgresql/inheritance.rb

@@ -55,9 +55,7 @@ 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(
+          @physically_inherited ||= connection.schema_cache.dependencies(
             defined?(@table_name) ? @table_name : decorated_table_name,
           ).present?
         rescue ActiveRecord::ConnectionNotEstablished