torque-postgresql 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25fb390d67c43461cf2c03096990149d2dbcae04072e96d69896d60f8e368863
-  data.tar.gz: e2910f192602059a71dbf3cfca2cc412e2d34eb1faacc51620058ce408c1be9f
+  metadata.gz: c677b1f2b2cdf150a4e8e9a817cd7a9a6e46680a353c3125aeb7ab65e1b85348
+  data.tar.gz: 72a25a13491d9349a813484be40c43cacc767355060ba16375da7b7f41739249
 SHA512:
-  metadata.gz: c664a0e98b7cc78b5930d4e3273330caa49cb8a18b792892cc42dae96b2392ebc61b71043c758c5e0abc3c54b12f8ee567fc53a48ad9f6765726ed1e000e2770
-  data.tar.gz: cfdb00e3740a05f2cabc1ccb25070ce05f5a628faa84209a899d5a247c17465dba0cac0a09a305e0c19fb05fb456c8d87e05107c9f0acb66803226a86ae2083b
+  metadata.gz: 1b6bdeeb8ca02a6027a79fc0d896716603792c1d4cee95131995ef944075f13b983a583a22eb4e3b6b590b8430b7b4eb4469522cf76b47daa30b8c2dd35a7318
+  data.tar.gz: eca4f269833a0823442f247cb065f14fe412c85063e5df8e751a20a366fd296f02db3ad2720b02d7a4169c73b38c1bbfe29160f292671a8a5cf0a23b4ffa9261

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

@@ -13,21 +13,15 @@ module Torque
           statements << accept(o.primary_keys) if o.primary_keys
 
           if supports_indexes_in_create?
-            statements.concat(o.indexes.map do |column_name, options|
-              index_in_create(o.name, column_name, options)
-            end)
+            statements.concat(o.indexes.map { |c, o| index_in_create(o.name, c, o) })
           end
 
           if supports_foreign_keys?
-            statements.concat(o.foreign_keys.map do |to_table, options|
-              foreign_key_in_create(o.name, to_table, options)
-            end)
+            statements.concat(o.foreign_keys.map { |fk| accept fk })
           end
 
           if respond_to?(:supports_check_constraints?) && supports_check_constraints?
-            statements.concat(o.check_constraints.map do |expression, options|
-              check_constraint_in_create(o.name, expression, options)
-            end)
+            statements.concat(o.check_constraints.map { |chk| accept chk })
           end
 
           create_sql << "(#{statements.join(', ')})" \

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    class AuxiliaryStatement
+      class Recursive < AuxiliaryStatement
+        # Setup any additional option in the recursive mode
+        def initialize(*, **options)
+          super
+
+          @connect = options[:connect]&.to_a&.first
+          @union_all = options[:union_all]
+          @sub_query = options[:sub_query]
+
+          if options.key?(:with_depth)
+            @depth = options[:with_depth].values_at(:name, :start, :as)
+            @depth[0] ||= 'depth'
+          end
+
+          if options.key?(:with_path)
+            @path = options[:with_path].values_at(:name, :source, :as)
+            @path[0] ||= 'path'
+          end
+        end
+
+        private
+
+          # Build the string or arel query
+          def build_query(base)
+            # Expose columns and get the list of the ones for select
+            columns = expose_columns(base, @query.try(:arel_table))
+            sub_columns = columns.dup
+            type = @union_all.present? ? 'all' : ''
+
+            # Build any extra columns that are dynamic and from the recursion
+            extra_columns(base, columns, sub_columns)
+
+            # Prepare the query depending on its type
+            if @query.is_a?(String) && @sub_query.is_a?(String)
+              args = @args.each_with_object({}) { |h, (k, v)| h[k] = base.connection.quote(v) }
+              ::Arel.sql("(#{@query} UNION #{type.upcase} #{@sub_query})" % args)
+            elsif relation_query?(@query)
+              @query = @query.where(@where) if @where.present?
+              @bound_attributes.concat(@query.send(:bound_attributes))
+
+              if relation_query?(@sub_query)
+                @bound_attributes.concat(@sub_query.send(:bound_attributes))
+
+                sub_query = @sub_query.select(*sub_columns).arel
+                sub_query.from([@sub_query.arel_table, table])
+              else
+                sub_query = ::Arel.sql(@sub_query)
+              end
+
+              @query.select(*columns).arel.union(type, sub_query)
+            else
+              raise ArgumentError, <<-MSG.squish
+                Only String and ActiveRecord::Base objects are accepted as query and sub query
+                objects, #{@query.class.name} given for #{self.class.name}.
+              MSG
+            end
+          end
+
+          # Setup the statement using the class configuration
+          def prepare(base, settings)
+            super
+
+            prepare_sub_query(base, settings)
+          end
+
+          # Make sure that both parts of the union are ready
+          def prepare_sub_query(base, settings)
+            @union_all = settings.union_all if @union_all.nil?
+            @sub_query ||= settings.sub_query
+            @depth ||= settings.depth
+            @path ||= settings.path
+
+            # Collect the connection
+            @connect ||= settings.connect || begin
+              key = base.primary_key
+              [key.to_sym, :"parent_#{key}"] unless key.nil?
+            end
+
+            raise ArgumentError, <<-MSG.squish if @sub_query.nil? && @query.is_a?(String)
+              Unable to generate sub query from a string query. Please provide a `sub_query`
+              property on the "#{table_name}" settings.
+            MSG
+
+            if @sub_query.nil?
+              raise ArgumentError, <<-MSG.squish if @connect.blank?
+                Unable to generate sub query without setting up a proper way to connect it
+                with the main query. Please provide a `connect` property on the "#{table_name}"
+                settings.
+              MSG
+
+              left, right = @connect.map(&:to_s)
+              condition = @query.arel_table[right].eq(table[left])
+
+              if @query.where_values_hash.key?(right)
+                @sub_query = @query.unscope(where: right.to_sym).where(condition)
+              else
+                @sub_query = @query.where(condition)
+                @query = @query.where(right => nil)
+              end
+            elsif @sub_query.respond_to?(:call)
+              # Call a proc to get the real sub query
+              call_args = @sub_query.try(:arity) === 0 ? [] : [OpenStruct.new(@args)]
+              @sub_query = @sub_query.call(*call_args)
+            end
+          end
+
+          # Add depth and path if they were defined in settings
+          def extra_columns(base, columns, sub_columns)
+            return if @query.is_a?(String) || @sub_query.is_a?(String)
+
+            # Add the connect attribute to the query
+            if defined?(@connect)
+              columns.unshift(@query.arel_table[@connect[0]])
+              sub_columns.unshift(@sub_query.arel_table[@connect[0]])
+            end
+
+            # Build a column to represent the depth of the recursion
+            if @depth.present?
+              name, start, as = @depth
+              col = table[name]
+              base.select_extra_values += [col.as(as)] unless as.nil?
+
+              columns << ::Arel.sql(start.to_s).as(name)
+              sub_columns << (col + ::Arel.sql('1')).as(name)
+            end
+
+            # Build a column to represent the path of the record access
+            if @path.present?
+              name, source, as = @path
+              source = @query.arel_table[source || @connect[0]]
+
+              col = table[name]
+              base.select_extra_values += [col.as(as)] unless as.nil?
+              parts = [col, source.cast(:varchar)]
+
+              columns << ::Arel.array([source]).cast(:varchar, true).as(name)
+              sub_columns << ::Arel::Nodes::NamedFunction.new('array_append', parts).as(name)
+            end
+          end
+
+      end
+    end
+  end
+end

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)
+          :polymorphic, :through, :union_all, :connect)
 
-        attr_reader :base, :source
+        attr_reader :base, :source, :depth, :path
         alias_method :select, :attributes
         alias_method :cte, :source
 
@@ -14,9 +14,10 @@ module Torque
         delegate :table, :table_name, to: :@source
         delegate :sql, to: ::Arel
 
-        def initialize(base, source)
+        def initialize(base, source, recursive = false)
           @base = base
           @source = source
+          @recursive = recursive
         end
 
         def base_name
@@ -27,6 +28,38 @@ 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?
@@ -41,36 +74,55 @@ module Torque
 
         alias column col
 
-        # There are two ways of setting the query:
+        # There are three ways of setting the query:
         # - A simple relation based on a Model
         # - A Arel-based select manager
-        # - A string or a proc that requires the table name as first argument
+        # - A string or a proc
         def query(value = nil, command = nil)
           return @query if value.nil?
-          return @query = value if relation_query?(value)
 
-          if value.is_a?(::Arel::SelectManager)
-            @query = value
-            @query_table = value.source.left.name
-            return
-          end
+          @query = sanitize_query(value, command)
+        end
 
-          valid_type = command.respond_to?(:call) || command.is_a?(String)
+        # 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?
 
-          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
+          @sub_query = sanitize_query(value, command)
+        end
+
+        # 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 unless valid_type
-            Only relation, string and proc are valid object types for query,
-            #{command.inspect} given.
-          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)
 
-          @query = command
-          @query_table = ::Arel::Table.new(value)
+          @connect = 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,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'auxiliary_statement/settings'
+require_relative 'auxiliary_statement/recursive'
 
 module Torque
   module PostgreSQL
@@ -8,17 +9,20 @@ module Torque
       TABLE_COLUMN_AS_STRING = /\A(?:"?(\w+)"?\.)?"?(\w+)"?\z/.freeze
 
       class << self
-        attr_reader :config
+        attr_reader :config, :table_name
 
         # 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(AuxiliaryStatement))
+
+          base.const_set(const, Class.new(self)).tap do |klass|
+            klass.instance_variable_set(:@table_name, name.to_s)
+          end
         end
 
         # Create a new instance of an auxiliary statement
-        def instantiate(statement, base, options = nil)
+        def instantiate(statement, base, **options)
           klass = while base < ActiveRecord::Base
             list = base.auxiliary_statements_list
             break list[statement] if list.present? && list.key?(statement)
@@ -26,15 +30,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, options = nil, bound_attributes = [], join_sources = [])
-          klass = instantiate(statement, base, options)
+        def build(statement, base, bound_attributes = [], join_sources = [], **options)
+          klass = instantiate(statement, base, **options)
           result = klass.build(base)
 
           bound_attributes.concat(klass.bound_attributes)
@@ -56,7 +60,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(AuxiliaryStatement)
+          klass = Class.new(self)
 
           if block_given?
             klass.instance_variable_set(:@table_name, table_or_settings)
@@ -89,7 +93,8 @@ module Torque
         def configure(base, instance)
           return @config unless @config.respond_to?(:call)
 
-          settings = Settings.new(base, instance)
+          recursive = self < AuxiliaryStatement::Recursive
+          settings = Settings.new(base, instance, recursive)
           settings.instance_exec(settings, &@config)
           settings
         end
@@ -98,11 +103,6 @@ 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,15 +111,14 @@ module Torque
       attr_reader :bound_attributes, :join_sources
 
       # Start a new auxiliary statement giving extra options
-      def initialize(*args)
-        options = args.extract_options!
+      def initialize(*, **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.fetch(:join_type, nil)
+        @join_type = options[:join_type]
 
         @bound_attributes = []
         @join_sources = []
@@ -131,7 +130,7 @@ module Torque
         @join_sources.clear
 
         # Prepare all the data for the statement
-        prepare(base)
+        prepare(base, configure(base, self))
 
         # Add the join condition to the list
         @join_sources << build_join(base)
@@ -141,9 +140,9 @@ module Torque
       end
 
       private
+
         # Setup the statement using the class configuration
-        def prepare(base)
-          settings = configure(base, self)
+        def prepare(base, settings)
           requires = Array.wrap(settings.requires).flatten.compact
           @dependencies = ensure_dependencies(requires, base).flatten.compact
 
@@ -151,14 +150,12 @@ module Torque
           @query = settings.query
 
           # Call a proc to get the real query
-          if @query.methods.include?(:call)
+          if @query.respond_to?(:call)
             call_args = @query.try(:arity) === 0 ? [] : [OpenStruct.new(@args)]
             @query = @query.call(*call_args)
-            @args = []
           end
 
-          # Manually set the query table when it's not an relation query
-          @query_table = settings.query_table unless relation_query?(@query)
+          # Merge select attributes provided on the instance creation
           @select = settings.attributes.merge(@select) if settings.attributes.present?
 
           # Merge join settings
@@ -168,7 +165,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
@@ -234,15 +231,6 @@ 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
@@ -263,21 +251,31 @@ 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
-          @select.map do |left, right|
-            base.select_extra_values += [table[right.to_s]]
-            project(left, query_table).as(right.to_s) if query_table
+          list.filter_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
         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 |dependent, options|
-            dependent_klass = base.model.auxiliary_statements_list[dependent]
+          (list + with_options).map do |name, options|
+            dependent_klass = base.model.auxiliary_statements_list[name]
 
             raise ArgumentError, <<-MSG.squish if dependent_klass.nil?
-              The '#{dependent}' auxiliary statement dependency can't found on
+              The '#{name}' auxiliary statement dependency can't found on
               #{self.class.name}.
             MSG
 
@@ -285,7 +283,8 @@ module Torque
               cte.is_a?(dependent_klass)
             end
 
-            AuxiliaryStatement.build(dependent, base, options, bound_attributes, join_sources)
+            options ||= {}
+            AuxiliaryStatement.build(name, base, bound_attributes, join_sources, **options)
           end
         end
 

data/lib/torque/postgresql/base.rb

@@ -252,7 +252,7 @@ module Torque
           # attributes key:
           # Provides a map of attributes to be exposed to the main query.
           #
-          # For instace, if the statement query has an 'id' column that you
+          # For instance, if the statement query has an 'id' column that you
           # want it to be accessed on the main query as 'item_id',
           # you can use:
           #   attributes id: :item_id, 'MAX(id)' => :max_id,
@@ -293,6 +293,16 @@ 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

@@ -63,6 +63,10 @@ module Torque
       # auxiliary statement in order to perform detached CTEs
       cte.exposed_class = 'TorqueCTE'
 
+      # Estipulate a class name (which may contain namespace) that expose the
+      # recursive auxiliary statement in order to perform detached CTEs
+      cte.exposed_recursive_class = 'TorqueRecursiveCTE'
+
     end
 
     # Configure ENUM features

data/lib/torque/postgresql/inheritance.rb

@@ -55,7 +55,9 @@ module Torque
 
         # Check if the model's table depends on any inheritance
         def physically_inherited?
-          @physically_inherited ||= connection.schema_cache.dependencies(
+          return @physically_inherited if defined?(@physically_inherited)
+
+          @physically_inherited = connection.schema_cache.dependencies(
             defined?(@table_name) ? @table_name : decorated_table_name,
           ).present?
         rescue ActiveRecord::ConnectionNotEstablished

data/lib/torque/postgresql/railtie.rb

@@ -30,11 +30,15 @@ module Torque
           Torque::PostgreSQL::Attributes::Enum.lookup(name).sample
         end
 
-        # Define the exposed constant for auxiliary statements
+        # Define the exposed constant for both types of auxiliary statements
         if torque_config.auxiliary_statement.exposed_class.present?
           *ns, name = torque_config.auxiliary_statement.exposed_class.split('::')
           base = ns.present? ? Object.const_get(ns.join('::')) : Object
           base.const_set(name, Torque::PostgreSQL::AuxiliaryStatement)
+
+          *ns, name = torque_config.auxiliary_statement.exposed_recursive_class.split('::')
+          base = ns.present? ? Object.const_get(ns.join('::')) : Object
+          base.const_set(name, Torque::PostgreSQL::AuxiliaryStatement::Recursive)
         end
       end
     end

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

@@ -10,22 +10,14 @@ module Torque
         # :nodoc:
         def auxiliary_statements_values=(value); set_value(:auxiliary_statements, value); end
 
-        # Set use of an auxiliary statement already configurated on the model
-        def with(*args)
-          spawn.with!(*args)
+        # Set use of an auxiliary statement
+        def with(*args, **settings)
+          spawn.with!(*args, **settings)
         end
 
         # Like #with, but modifies relation in place.
-        def with!(*args)
-          options = args.extract_options!
-          args.each do |table|
-            instance = table.is_a?(Class) && table < PostgreSQL::AuxiliaryStatement \
-              ? table.new(options) \
-              : PostgreSQL::AuxiliaryStatement.instantiate(table, self, options)
-
-            self.auxiliary_statements_values += [instance]
-          end
-
+        def with!(*args, **settings)
+          instantiate_auxiliary_statements(*args, **settings)
           self
         end
 
@@ -47,8 +39,23 @@ module Torque
           # Hook arel build to add the distinct on clause
           def build_arel(*)
             arel = super
-            subqueries = build_auxiliary_statements(arel)
-            subqueries.nil? ? arel : arel.with(subqueries)
+            type = auxiliary_statement_type
+            sub_queries = build_auxiliary_statements(arel)
+            sub_queries.nil? ? arel : arel.with(*type, *sub_queries)
+          end
+
+          # Instantiate one or more auxiliary statements for the given +klass+
+          def instantiate_auxiliary_statements(*args, **options)
+            klass = PostgreSQL::AuxiliaryStatement
+            klass = klass::Recursive if options.delete(:recursive).present?
+
+            self.auxiliary_statements_values += args.map do |table|
+              if table.is_a?(Class) && table < klass
+                table.new(**options)
+              else
+                klass.instantiate(table, self, **options)
+              end
+            end
           end
 
           # Build all necessary data for auxiliary statements
@@ -59,6 +66,12 @@ module Torque
             end
           end
 
+          # Return recursive if any auxiliary statement is recursive
+          def auxiliary_statement_type
+            klass = PostgreSQL::AuxiliaryStatement::Recursive
+            :recursive if auxiliary_statements_values.any?(klass)
+          end
+
           # Throw an error showing that an auxiliary statement of the given
           # table name isn't defined
           def auxiliary_statement_error(name)

data/lib/torque/postgresql/version.rb

@@ -2,6 +2,6 @@
 
 module Torque
   module PostgreSQL
-    VERSION = '3.1.0'
+    VERSION = '3.2.0'
   end
 end

data/spec/models/category.rb

@@ -0,0 +1,2 @@
+class Category< ActiveRecord::Base
+end