cuatlan-activerecord-hierarchical_query 1.0.1

data/lib/active_record/hierarchical_query/cte/cycle_detector.rb

@@ -0,0 +1,54 @@
+module ActiveRecord
+  module HierarchicalQuery
+    module CTE
+      class CycleDetector
+        COLUMN_NAME = '__path'.freeze
+
+        delegate :klass, :table, to: :@query
+
+        # @param [ActiveRecord::HierarchicalQuery::Query] query
+        def initialize(query)
+          @query = query
+        end
+
+        def apply_to_non_recursive(arel)
+          if enabled?
+            arel.project Arel::Nodes::PostgresArray.new([primary_key]).as(column_name)
+          end
+
+          arel
+        end
+
+        def apply_to_recursive(arel)
+          if enabled?
+            arel.project Arel::Nodes::ArrayConcat.new(parent_column, primary_key)
+            arel.constraints << Arel::Nodes::Not.new(primary_key.eq(any(parent_column)))
+          end
+
+          arel
+        end
+
+        private
+        def enabled?
+          @query.nocycle_value
+        end
+
+        def column_name
+          COLUMN_NAME
+        end
+
+        def parent_column
+          @query.recursive_table[column_name]
+        end
+
+        def primary_key
+          table[klass.primary_key]
+        end
+
+        def any(argument)
+          Arel::Nodes::NamedFunction.new('ANY', [argument])
+        end
+      end
+    end
+  end
+end

data/lib/active_record/hierarchical_query/cte/non_recursive_term.rb

@@ -0,0 +1,55 @@
+# coding: utf-8
+
+module ActiveRecord
+  module HierarchicalQuery
+    module CTE
+      class NonRecursiveTerm
+        DISALLOWED_CLAUSES = :order, :limit, :offset, :group, :having
+
+        attr_reader :builder
+        delegate :query, to: :builder
+
+        # @param [ActiveRecord::HierarchicalQuery::CTE::QueryBuilder] builder
+        def initialize(builder)
+          @builder = builder
+        end
+
+        def bind_values
+          scope.bound_attributes
+        end
+
+        def arel
+          arel = scope.arel
+
+          builder.cycle_detector.apply_to_non_recursive(arel)
+        end
+
+        private
+        def scope
+          @scope ||= query.
+              start_with_value.
+              select(columns).
+              except(*DISALLOWED_CLAUSES).
+              reorder(nil)
+        end
+
+        def columns
+          columns = builder.columns.to_a
+
+          if query.orderings.any?
+            columns << ordering
+          end
+
+          columns
+        end
+
+        def ordering
+          value = query.orderings.row_number_expression
+          column_name = query.ordering_column_name
+
+          Arel::Nodes::PostgresArray.new([value]).as(column_name)
+        end
+      end # class NonRecursiveTerm
+    end
+  end
+end

data/lib/active_record/hierarchical_query/cte/query_builder.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+require 'active_record/hierarchical_query/cte/columns'
+require 'active_record/hierarchical_query/cte/cycle_detector'
+require 'active_record/hierarchical_query/cte/union_term'
+
+module ActiveRecord
+  module HierarchicalQuery
+    module CTE
+      # CTE query builder
+      class QueryBuilder
+        attr_reader :query,
+                    :columns,
+                    :cycle_detector,
+                    :options
+
+        delegate :klass, :table, :recursive_table, to: :query
+
+        # @param [ActiveRecord::HierarchicalQuery::Query] query
+        def initialize(query, options: {})
+          @query = query
+          @columns = Columns.new(@query)
+          @cycle_detector = CycleDetector.new(@query)
+          @options = options
+        end
+
+        def bind_values
+          union_term.bind_values
+        end
+
+        # @return [Arel::SelectManager]
+        def build_arel
+          build_manager
+          build_select
+          build_limits
+          build_order
+
+          @arel
+        end
+
+        private
+        def build_manager
+          @arel = Arel::SelectManager.new(table).
+              with(:recursive, with_query).
+              from(recursive_table)
+        end
+
+        # "categories__recursive" AS (
+        #   SELECT ... FROM "categories"
+        #   UNION ALL
+        #   SELECT ... FROM "categories"
+        #   INNER JOIN "categories__recursive" ON ...
+        # )
+        def with_query
+          Arel::Nodes::As.new(recursive_table, union_term.arel)
+        end
+
+        def union_term
+          @union_term ||= UnionTerm.new(self, @options)
+        end
+
+        def build_select
+          if @query.distinct_value
+            @arel.project(recursive_table[Arel.star]).distinct
+          else
+            @arel.project(recursive_table[Arel.star])
+          end
+        end
+
+        def build_limits
+          @arel.take(query.limit_value).skip(query.offset_value)
+        end
+
+        def build_order
+          @arel.order(order_column.asc) if should_order?
+        end
+
+        def should_order?
+          query.orderings.any? && (query.limit_value || query.offset_value)
+        end
+
+        def order_column
+          recursive_table[query.ordering_column_name]
+        end
+      end
+    end
+  end
+end

data/lib/active_record/hierarchical_query/cte/recursive_term.rb

@@ -0,0 +1,47 @@
+module ActiveRecord
+  module HierarchicalQuery
+    module CTE
+      class RecursiveTerm
+        # @return [ActiveRecord::HierarchicalQuery::CTE::Query]
+        attr_reader :builder
+
+        delegate :query, to: :builder
+
+        # @param [ActiveRecord::HierarchicalQuery::CTE::QueryBuilder] builder
+        def initialize(builder)
+          @builder = builder
+        end
+
+        def bind_values
+          scope.bound_attributes
+        end
+
+        def arel
+          arel = scope.arel
+                      .join(query.recursive_table).on(query.join_conditions)
+
+          builder.cycle_detector.apply_to_recursive(arel)
+        end
+
+        private
+        def scope
+          @scope ||= query.child_scope_value.select(columns).reorder(nil)
+        end
+
+        def columns
+          columns = builder.columns.to_a
+          columns << ordering if query.orderings.any?
+          columns
+        end
+
+        def ordering
+          column_name = query.ordering_column_name
+          left = query.recursive_table[column_name]
+          right = query.orderings.row_number_expression
+
+          Arel::Nodes::ArrayConcat.new(left, right)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/hierarchical_query/cte/union_term.rb

@@ -0,0 +1,35 @@
+require 'active_record/hierarchical_query/cte/non_recursive_term'
+require 'active_record/hierarchical_query/cte/recursive_term'
+
+module ActiveRecord
+  module HierarchicalQuery
+    module CTE
+      class UnionTerm
+        # @param [ActiveRecord::HierarchicalQuery::CTE::QueryBuilder] builder
+        def initialize(builder, options = {})
+          @builder = builder
+          @union_type = options.fetch(:union_type, :all)
+        end
+
+        def bind_values
+          non_recursive_term.bind_values + recursive_term.bind_values
+        end
+
+        def arel
+          non_recursive_term.arel.union(union_type, recursive_term.arel)
+        end
+
+        private
+        attr_reader :union_type
+
+        def recursive_term
+          @rt ||= RecursiveTerm.new(@builder)
+        end
+
+        def non_recursive_term
+          @nrt ||= NonRecursiveTerm.new(@builder)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/hierarchical_query/join_builder.rb

@@ -0,0 +1,107 @@
+require 'active_record/hierarchical_query/cte/query_builder'
+
+module ActiveRecord
+  module HierarchicalQuery
+    class JoinBuilder
+      # @param [ActiveRecord::HierarchicalQuery::Query] query
+      # @param [ActiveRecord::Relation] join_to
+      # @param [#to_s] subquery_alias
+      # @param [Hash] options (:outer_join_hierarchical, :union_type)
+      def initialize(query, join_to, subquery_alias, options = {})
+        @query = query
+        @builder = CTE::QueryBuilder.new(query, options: options)
+        @relation = join_to
+        @alias = Arel::Table.new(subquery_alias)
+        @options = options
+      end
+
+      def build
+        if ActiveRecord.gem_version >= Gem::Version.new('5.2.0')
+          relation = @relation
+
+          # add ordering by "__order_column"
+          relation.order_values += order_columns if ordered?
+
+          relation = relation.joins(joined_arel_node)
+
+          relation
+        else
+          relation = @relation
+
+          # add ordering by "__order_column"
+          relation.order_values += order_columns if ordered?
+
+          relation = relation.joins(joined_arel_node)
+
+          # copy bound variables from inner subquery
+          relation.bind_values += bind_values
+
+          relation
+        end
+      end
+
+      private
+      def joined_arel_node
+        @options[:outer_join_hierarchical] == true ? outer_join : inner_join
+      end
+
+      def inner_join
+        Arel::Nodes::InnerJoin.new(aliased_subquery, constraint)
+      end
+
+      def outer_join
+        Arel::Nodes::OuterJoin.new(aliased_subquery, constraint)
+      end
+
+      def aliased_subquery
+        SubqueryAlias.new(subquery, @alias)
+      end
+
+      def subquery
+        Arel::Nodes::Grouping.new(cte_arel.ast)
+      end
+
+      def cte_arel
+        @cte_arel ||= @builder.build_arel
+      end
+
+      def constraint
+        Arel::Nodes::On.new(primary_key.eq(foreign_key))
+      end
+
+      def primary_key
+        @relation.table[@relation.klass.primary_key]
+      end
+
+      def custom_foreign_key
+        @options[:foreign_key]
+      end
+
+      def foreign_key
+        custom_foreign_key ? @alias[custom_foreign_key] : @alias[@query.klass.primary_key]
+      end
+
+      def bind_values
+        @builder.bind_values
+      end
+
+      def ordered?
+        @query.orderings.any?
+      end
+
+      def order_columns
+        [@query.recursive_table[@query.ordering_column_name].asc]
+      end
+
+      # This node is required to support joins to aliased Arel nodes
+      class SubqueryAlias < Arel::Nodes::As
+        attr_reader :table_name
+
+        def initialize(subquery, alias_node)
+          super
+          @table_name = alias_node.name
+        end
+      end
+    end
+  end
+end

data/lib/active_record/hierarchical_query/orderings.rb

@@ -0,0 +1,119 @@
+module ActiveRecord
+  module HierarchicalQuery
+    class Orderings
+      NATURAL_SORT_TYPES = Set[
+          :integer, :float, :decimal,
+          :datetime, :timestamp, :time, :date,
+          :boolean, :itet, :cidr, :ltree
+      ]
+
+      include Enumerable
+
+      attr_reader :order_values, :table
+
+      # @param [Array] order_values
+      # @param [Arel::Table] table
+      def initialize(order_values, table)
+        @order_values, @table = order_values, table
+        @values = nil # cached orderings
+      end
+
+      def each(&block)
+        return @values.each(&block) if @values
+        return enum_for(__method__) unless block_given?
+
+        @values = []
+
+        order_values.each do |value|
+          Array.wrap(as_orderings(value)).each do |ordering|
+            @values << ordering
+
+            yield ordering
+          end
+        end
+
+        @values
+      end
+
+      # Returns order expression to be inserted into SELECT clauses of both
+      # non-recursive and recursive terms.
+      #
+      # @return [Arel::Nodes::Node] order expression
+      def row_number_expression
+        if raw_ordering?
+          order_attribute
+        else
+          Arel.sql("ROW_NUMBER() OVER (ORDER BY #{map(&:to_sql).join(', ')})")
+        end
+      end
+
+      private
+      def as_orderings(value)
+        case value
+          when Arel::Nodes::Ordering
+            value
+
+          when Arel::Nodes::Node, Arel::Attributes::Attribute
+            value.asc
+
+          when Symbol
+            table[value].asc
+
+          when Hash
+            value.map { |field, dir| table[field].send(dir) }
+
+          when String
+            value.split(',').map do |expr|
+              string_as_ordering(expr)
+            end
+
+          else
+            raise 'Unknown expression in ORDER BY SIBLINGS clause'
+        end
+      end
+
+      def string_as_ordering(expr)
+        expr.strip!
+
+        if expr.gsub!(/\bdesc\z/i, '')
+          Arel.sql(expr).desc
+        else
+          expr.gsub!(/\basc\z/i, '')
+          Arel.sql(expr).asc
+        end
+      end
+
+      def raw_ordering?
+        ordered_by_attribute? &&
+            (column = order_column) &&
+            NATURAL_SORT_TYPES.include?(column.type)
+      end
+
+      def ordered_by_attribute?
+        one? && first.ascending? && order_attribute.is_a?(Arel::Attributes::Attribute)
+      end
+
+      def order_attribute
+        first.expr
+      end
+
+      def order_column
+        table = order_attribute.relation
+
+        engine = table.class.engine
+        if engine == ActiveRecord::Base
+          columns =
+            if engine.connection.respond_to?(:schema_cache)
+              engine.connection.schema_cache.columns_hash(table.name)
+            else
+              engine.connection_pool.columns_hash[table.name]
+            end
+        else
+          columns = engine.columns_hash
+        end
+
+        columns[order_attribute.name.to_s]
+      end
+    end
+  end
+end