activerecord-hierarchical_query 0.0.1

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

@@ -0,0 +1,39 @@
+require 'arel/visitors/depth_first'
+
+module ActiveRecord
+  module HierarchicalQuery
+    module CTE
+      class Columns
+        # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
+        def initialize(query)
+          @query = query
+        end
+
+        # returns columns to be selected from both recursive and non-recursive terms
+        def to_a
+          column_names = [@query.klass.primary_key] | connect_by_columns
+          column_names.map { |name| @query.table[name] }
+        end
+        alias_method :to_ary, :to_a
+
+        private
+        def connect_by_columns
+          extractor.call(@query.join_conditions).map { |column| column.name.to_s }
+        end
+
+        def extractor
+          target = []
+
+          ->(arel) {
+            visitor = Arel::Visitors::DepthFirst.new do |node|
+              target << node if node.is_a?(Arel::Attributes::Attribute)
+            end
+            visitor.accept(arel)
+
+            target
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+module ActiveRecord
+  module HierarchicalQuery
+    module CTE
+      class CycleDetector
+        COLUMN_NAME = '__path'.freeze
+
+        attr_reader :query
+
+        delegate :builder, :to => :query
+        delegate :klass, :table, :to => :builder
+
+        # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
+        def initialize(query)
+          @query = query
+        end
+
+        def column_name
+          COLUMN_NAME
+        end
+
+        def visit_non_recursive(arel)
+          visit arel do
+            arel.project Arel::Nodes::PostgresArray.new([primary_key]).as(column_name)
+          end
+        end
+
+        def visit_recursive(arel)
+          visit arel do
+            arel.project Arel::Nodes::ArrayConcat.new(parent_column, primary_key)
+            arel.constraints << Arel::Nodes::Not.new(primary_key.eq(any(parent_column)))
+          end
+        end
+
+        private
+        def enabled?
+          builder.nocycle_value
+        end
+
+        def parent_column
+          query.recursive_table[column_name]
+        end
+
+        def primary_key
+          table[klass.primary_key]
+        end
+
+        def visit(object)
+          if enabled?
+            yield
+          end
+
+          object
+        end
+
+        def any(argument)
+          Arel::Nodes::NamedFunction.new('ANY', [argument])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module ActiveRecord
+  module HierarchicalQuery
+    module CTE
+      class JoinBuilder
+        # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
+        # @param [ActiveRecord::Relation] join_to
+        # @param [#to_s] subquery_alias
+        def initialize(query, join_to, subquery_alias)
+          @query = query
+          @relation = join_to
+          @alias = Arel::Table.new(subquery_alias, ActiveRecord::Base)
+        end
+
+        def build
+          apply_ordering { @relation.joins(inner_join.to_sql) }
+        end
+
+        private
+        def inner_join
+          Arel::Nodes::InnerJoin.new(aliased_subquery, constraint)
+        end
+
+        def primary_key
+          @relation.table[@relation.klass.primary_key]
+        end
+
+        def foreign_key
+          @alias[@query.klass.primary_key]
+        end
+
+        def constraint
+          Arel::Nodes::On.new(primary_key.eq(foreign_key))
+        end
+
+        def subquery
+          Arel::Nodes::Grouping.new(@query.arel.ast)
+        end
+
+        def aliased_subquery
+          Arel::Nodes::As.new(subquery, @alias)
+        end
+
+        def apply_ordering
+          scope = yield
+
+          if @query.orderings.any?
+            scope.order(@query.order_clause)
+          else
+            scope
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# coding: utf-8
+
+require 'arel/nodes/postgresql'
+
+module ActiveRecord
+  module HierarchicalQuery
+    module CTE
+      class NonRecursiveTerm
+        DISALLOWED_CLAUSES = :order, :limit, :offset
+
+        attr_reader :query
+        delegate :builder, :orderings, :cycle_detector, :to => :query
+        delegate :start_with_value, :klass, :to => :builder
+
+        # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
+        def initialize(query)
+          @query = query
+        end
+
+        def arel
+          arel = scope.select(query.columns)
+                      .select(ordering_column)
+                      .except(*DISALLOWED_CLAUSES)
+                      .arel
+
+          cycle_detector.visit_non_recursive(arel)
+        end
+
+        private
+        def scope
+          start_with_value || klass.__send__(HierarchicalQuery::DELEGATOR_SCOPE)
+        end
+
+        def ordering_column
+          if orderings.any?
+            Arel::Nodes::PostgresArray.new([orderings.row_number_expression]).as(orderings.column_name)
+          else
+            []
+          end
+        end
+      end # class NonRecursiveTerm
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+require 'set'
+require 'active_support/core_ext/array/wrap'
+
+module ActiveRecord
+  module HierarchicalQuery
+    module CTE
+      class Orderings
+        include Enumerable
+
+        ORDERING_COLUMN_ALIAS = '__order_column'
+
+        NATURAL_SORT_TYPES = Set[
+            :integer, :float, :decimal,
+            :datetime, :timestamp, :time, :date,
+            :boolean, :itet, :cidr, :ltree
+        ]
+
+        delegate :table, :to => :@builder
+        delegate :each, :to => :arel_nodes
+
+        # @param [ActiveRecord::HierarchicalQuery::Builder] builder
+        def initialize(builder)
+          @builder = builder
+        end
+
+        def arel_nodes
+          @arel_nodes ||= @builder.order_values.each_with_object([]) do |value, orderings|
+            orderings.concat Array.wrap(as_orderings(value))
+          end
+        end
+
+        def row_number_expression
+          if raw_ordering?
+            order_attribute
+          else
+            Arel.sql("ROW_NUMBER() OVER (ORDER BY #{arel_nodes.map(&:to_sql).join(', ')})")
+          end
+        end
+
+        def column_name
+          ORDERING_COLUMN_ALIAS
+        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!(/\s+desc\z/i, '')
+            Arel.sql(expr).desc
+          else
+            expr.gsub!(/\s+asc\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?
+          arel_nodes.one? && first.ascending? && order_attribute.is_a?(Arel::Attributes::Attribute)
+        end
+
+        def order_attribute
+          first.expr
+        end
+
+        def order_column
+          table = order_attribute.relation
+
+          if table.engine == ActiveRecord::Base
+            columns = table.engine.connection_pool.columns_hash[table.name]
+          else
+            columns = table.engine.columns_hash
+          end
+
+          columns[order_attribute.name.to_s]
+        end
+      end # class Orderings
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+require 'active_record/hierarchical_query/cte/columns'
+require 'active_record/hierarchical_query/cte/cycle_detector'
+require 'active_record/hierarchical_query/cte/join_builder'
+require 'active_record/hierarchical_query/cte/orderings'
+require 'active_record/hierarchical_query/cte/union_term'
+
+module ActiveRecord
+  module HierarchicalQuery
+    module CTE
+      class Query
+        attr_reader :builder,
+                    :columns,
+                    :orderings,
+                    :cycle_detector
+
+        delegate :klass, :table, :to => :builder
+
+        # @param [ActiveRecord::HierarchicalQuery::Builder] builder
+        def initialize(builder)
+          @builder = builder
+          @orderings = Orderings.new(builder)
+          @columns = Columns.new(self)
+          @cycle_detector = CycleDetector.new(self)
+        end
+
+        def build_join(relation, subquery_alias)
+          JoinBuilder.new(self, relation, subquery_alias).build
+        end
+
+        # @return [Arel::SelectManager]
+        def arel
+          apply_ordering { build_arel }
+        end
+
+        # @return [Arel::Table]
+        def recursive_table
+          @recursive_table ||= Arel::Table.new("#{table.name}__recursive")
+        end
+
+        def join_conditions
+          builder.connect_by_value[recursive_table, table]
+        end
+
+        def order_clause
+          recursive_table[orderings.column_name].asc
+        end
+
+        private
+        # "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
+          UnionTerm.new(self)
+        end
+
+        def apply_ordering
+          arel = yield
+
+          if should_order?
+            apply_ordering_to(arel)
+          else
+            arel
+          end
+        end
+
+        def build_arel
+          Arel::SelectManager.new(table.engine).
+            with(:recursive, with_query).
+            from(recursive_table).
+            project(recursive_table[Arel.star]).
+            take(builder.limit_value).
+            skip(builder.offset_value)
+        end
+
+        def should_order?
+          orderings.any? && builder.limit_value || builder.offset_value
+        end
+
+        def apply_ordering_to(select_manager)
+          select_manager.order(order_clause)
+        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 :query
+
+        delegate :orderings,
+                 :cycle_detector,
+                 :recursive_table,
+                 :join_conditions,
+                 :to => :query
+
+        # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
+        def initialize(query)
+          @query = query
+        end
+
+        def arel
+          arel = scope.select(query.columns)
+                      .select(ordering_column)
+                      .arel
+                      .join(recursive_table).on(join_conditions)
+
+          cycle_detector.visit_recursive(arel)
+        end
+
+        private
+        def scope
+          query.builder.child_scope_value
+        end
+
+        def ordering_column
+          if orderings.any?
+            Arel::Nodes::ArrayConcat.new(parent_ordering_column, orderings.row_number_expression)
+          else
+            []
+          end
+        end
+
+        def parent_ordering_column
+          recursive_table[orderings.column_name]
+        end
+      end
+    end
+  end
+end