activerecord-hierarchical_query 0.0.2 → 0.0.5

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

@@ -3,29 +3,43 @@ module ActiveRecord
     module CTE
       class RecursiveTerm
         # @return [ActiveRecord::HierarchicalQuery::CTE::Query]
-        attr_reader :query
+        attr_reader :builder
 
-        delegate :recursive_table,
-                 :join_conditions,
-                 :adapter,
-                 :to => :query
+        delegate :query, to: :builder
 
-        # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
-        def initialize(query)
-          @query = query
+        # @param [ActiveRecord::HierarchicalQuery::CTE::QueryBuilder] builder
+        def initialize(builder)
+          @builder = builder
+        end
+
+        def bind_values
+          scope.bind_values
         end
 
         def arel
-          arel = scope.select(query.columns)
-                      .arel
-                      .join(recursive_table).on(join_conditions)
+          arel = scope.arel
+                      .join(query.recursive_table).on(query.join_conditions)
 
-          adapter.visit(:recursive, arel)
+          builder.cycle_detector.apply_to_recursive(arel)
         end
 
         private
         def scope
-          query.builder.child_scope_value
+          @scope ||= query.child_scope_value.select(columns)
+        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

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

@@ -5,22 +5,26 @@ module ActiveRecord
   module HierarchicalQuery
     module CTE
       class UnionTerm
-        # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
-        def initialize(query)
-          @query = query
+        # @param [ActiveRecord::HierarchicalQuery::CTE::QueryBuilder] builder
+        def initialize(builder)
+          @builder = builder
+        end
+
+        def bind_values
+          non_recursive_term.bind_values + recursive_term.bind_values
         end
 
         def arel
-          non_recursive_term.union(:all, recursive_term)
+          non_recursive_term.arel.union(:all, recursive_term.arel)
         end
 
         private
         def recursive_term
-          RecursiveTerm.new(@query).arel
+          @rt ||= RecursiveTerm.new(@builder)
         end
 
         def non_recursive_term
-          NonRecursiveTerm.new(@query).arel
+          @nrt ||= NonRecursiveTerm.new(@builder)
         end
       end
     end

data/lib/active_record/hierarchical_query/join_builder.rb

@@ -1,21 +1,26 @@
+require 'active_record/hierarchical_query/cte/query_builder'
+
 module ActiveRecord
   module HierarchicalQuery
     class JoinBuilder
-      delegate :adapter, :to => :@query
-
-      # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
+      # @param [ActiveRecord::HierarchicalQuery::Query] query
       # @param [ActiveRecord::Relation] join_to
       # @param [#to_s] subquery_alias
       def initialize(query, join_to, subquery_alias)
         @query = query
+        @builder = CTE::QueryBuilder.new(query)
         @relation = join_to
         @alias = Arel::Table.new(subquery_alias, ActiveRecord::Base)
       end
 
       def build
         relation = @relation.joins(inner_join.to_sql)
+        # copy bound variables from inner subquery
+        relation.bind_values += bind_values
+        # add ordering by "__order_column"
+        relation.order_values += order_columns if ordered?
 
-        adapter.visit(:joined_relation, relation)
+        relation
       end
 
       private
@@ -23,6 +28,22 @@ module ActiveRecord
         Arel::Nodes::InnerJoin.new(aliased_subquery, constraint)
       end
 
+      def aliased_subquery
+        Arel::Nodes::As.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
@@ -31,16 +52,16 @@ module ActiveRecord
         @alias[@query.klass.primary_key]
       end
 
-      def constraint
-        Arel::Nodes::On.new(primary_key.eq(foreign_key))
+      def bind_values
+        @builder.bind_values
       end
 
-      def subquery
-        Arel::Nodes::Grouping.new(@query.arel.ast)
+      def ordered?
+        @query.orderings.any?
       end
 
-      def aliased_subquery
-        Arel::Nodes::As.new(subquery, @alias)
+      def order_columns
+        [@query.recursive_table[@query.ordering_column_name].asc]
       end
     end
   end

data/lib/active_record/hierarchical_query/orderings.rb

@@ -0,0 +1,113 @@
+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
+
+        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
+  end
+end

data/lib/active_record/hierarchical_query/{builder.rb → query.rb}

@@ -2,12 +2,16 @@
 
 require 'active_support/core_ext/array/extract_options'
 
-require 'active_record/hierarchical_query/cte/query'
+require 'active_record/hierarchical_query/orderings'
 require 'active_record/hierarchical_query/join_builder'
+require 'arel/nodes/postgresql'
 
 module ActiveRecord
   module HierarchicalQuery
-    class Builder
+    class Query
+      # @api private
+      ORDERING_COLUMN_NAME = '__order_column'.freeze
+
       # @api private
       attr_reader :klass,
                   :start_with_value,
@@ -19,15 +23,15 @@ module ActiveRecord
                   :nocycle_value
 
       # @api private
-      CHILD_SCOPE_METHODS = :where, :joins, :group, :having
+      CHILD_SCOPE_METHODS = :where, :joins, :group, :having, :bind
 
       def initialize(klass)
         @klass = klass
-        @query = CTE::Query.new(self)
 
-        @start_with_value = nil
+        # start with :all
+        @start_with_value = klass.__send__(HierarchicalQuery::DELEGATOR_SCOPE)
         @connect_by_value = nil
-        @child_scope_value = klass
+        @child_scope_value = klass.__send__(HierarchicalQuery::DELEGATOR_SCOPE)
         @limit_value = nil
         @offset_value = nil
         @nocycle_value = false
@@ -38,43 +42,49 @@ module ActiveRecord
       #
       # @example When scope given
       #   MyModel.join_recursive do |hierarchy|
-      #     hierarchy.start_with(MyModel.where(:parent_id => nil))
-      #              .connect_by(:id => :parent_id)
+      #     hierarchy.start_with(MyModel.where(parent_id: nil))
+      #              .connect_by(id: :parent_id)
       #   end
       #
       # @example When Hash given
       #   MyModel.join_recursive do |hierarchy|
-      #     hierarchy.start_with(:parent_id => nil)
-      #              .connect_by(:id => :parent_id)
+      #     hierarchy.start_with(parent_id: nil)
+      #              .connect_by(id: :parent_id)
       #   end
       #
+      # @example When String given
+      #    MyModel.join_recursive do |hierarchy|
+      #      hierararchy.start_with('parent_id = ?', 1)
+      #                 .connect_by(id: :parent_id)
+      #    end
+      #
       # @example When block given
       #   MyModel.join_recursive do |hierarchy|
-      #     hierarchy.start_with { |root| root.where(:parent_id => nil) }
-      #              .connect_by(:id => :parent_id)
+      #     hierarchy.start_with { |root| root.where(parent_id: nil) }
+      #              .connect_by(id: :parent_id)
       #   end
       #
       # @example When block with arity=0 given
       #   MyModel.join_recursive do |hierarchy|
-      #     hierarchy.start_with { where(:parent_id => nil) }
-      #              .connect_by(:id => :parent_id)
+      #     hierarchy.start_with { where(parent_id: nil) }
+      #              .connect_by(id: :parent_id)
       #   end
       #
       # @example Specify columns for root relation (PostgreSQL-specific)
       #   MyModel.join_recursive do |hierarchy|
       #     hierarchy.start_with { select('ARRAY[id] AS _path') }
-      #              .connect_by(:id => :parent_id)
-      #              .select('_path || id', :start_with => false) # `:start_with => false` tells not to include this expression into START WITH clause
+      #              .connect_by(id: :parent_id)
+      #              .select('_path || id', start_with: false) # `start_with: false` tells not to include this expression into START WITH clause
       #   end
       #
-      # @param [ActiveRecord::Relation, Hash, nil] scope root scope (optional).
-      # @return [ActiveRecord::HierarchicalQuery::Builder] self
-      def start_with(scope = nil, &block)
+      # @param [ActiveRecord::Relation, Hash, String, nil] scope root scope (optional).
+      # @return [ActiveRecord::HierarchicalQuery::Query] self
+      def start_with(scope = nil, *arguments, &block)
         raise ArgumentError, 'START WITH: scope or block expected, none given' unless scope || block
 
         case scope
-          when Hash
-            @start_with_value = klass.where(scope)
+          when Hash, String
+            @start_with_value = klass.where(scope, *arguments)
 
           when ActiveRecord::Relation
             @start_with_value = scope
@@ -103,7 +113,7 @@ module ActiveRecord
       # @example Specify relationship with Hash (traverse descendants)
       #   MyModel.join_recursive do |hierarchy|
       #     # join child rows with condition `parent.id = child.parent_id`
-      #     hierarchy.connect_by(:id => :parent_id)
+      #     hierarchy.connect_by(id: :parent_id)
       #   end
       #
       # @example Specify relationship with block (traverse descendants)
@@ -117,7 +127,7 @@ module ActiveRecord
       # @yieldparam [Arel::Table] parent parent rows table instance.
       # @yieldparam [Arel::Table] child child rows table instance.
       # @yieldreturn [Arel::Nodes::Node] relationship condition expressed as Arel node.
-      # @return [ActiveRecord::HierarchicalQuery::Builder] self
+      # @return [ActiveRecord::HierarchicalQuery::Query] self
       def connect_by(conditions = nil, &block)
         # convert hash to block which returns Arel node
         if conditions
@@ -136,7 +146,7 @@ module ActiveRecord
       #
       # @param [Array<Symbol, String, Arel::Attributes::Attribute, Arel::Nodes::Node>] columns
       # @option columns [true, false] :start_with include given columns to START WITH clause (true by default)
-      # @return [ActiveRecord::HierarchicalQuery::Builder] self
+      # @return [ActiveRecord::HierarchicalQuery::Query] self
       def select(*columns)
         options = columns.extract_options!
 
@@ -166,6 +176,7 @@ module ActiveRecord
       # @!method joins(*tables)
       # @!method group(*values)
       # @!method having(*conditions)
+      # @!method bind(value)
       CHILD_SCOPE_METHODS.each do |method|
         define_method(method) do |*args|
           @child_scope_value = @child_scope_value.public_send(method, *args)
@@ -177,7 +188,7 @@ module ActiveRecord
       # Specifies a limit for the number of records to retrieve.
       #
       # @param [Fixnum] value
-      # @return [ActiveRecord::HierarchicalQuery::Builder] self
+      # @return [ActiveRecord::HierarchicalQuery::Query] self
       def limit(value)
         @limit_value = value
 
@@ -187,7 +198,7 @@ module ActiveRecord
       # Specifies the number of rows to skip before returning row
       #
       # @param [Fixnum] value
-      # @return [ActiveRecord::HierarchicalQuery::Builder] self
+      # @return [ActiveRecord::HierarchicalQuery::Query] self
       def offset(value)
         @offset_value = value
 
@@ -198,18 +209,18 @@ module ActiveRecord
       #
       # @example
       #   MyModel.join_recursive do |hierarchy|
-      #     hierarchy.connect_by(:id => :parent_id)
+      #     hierarchy.connect_by(id: :parent_id)
       #              .order_siblings(:name)
       #   end
       #
       # @example
       #   MyModel.join_recursive do |hierarchy|
-      #     hierarchy.connect_by(:id => :parent_id)
+      #     hierarchy.connect_by(id: :parent_id)
       #              .order_siblings('name DESC, created_at ASC')
       #   end
       #
       # @param [<Symbol, String, Arel::Nodes::Node, Arel::Attributes::Attribute>] columns
-      # @return [ActiveRecord::HierarchicalQuery::Builder] self
+      # @return [ActiveRecord::HierarchicalQuery::Query] self
       def order_siblings(*columns)
         @order_values += columns
 
@@ -221,7 +232,7 @@ module ActiveRecord
       # endless loops if your tree could contain cycles.
       #
       # @param [true, false] value
-      # @return [ActiveRecord::HierarchicalQuery::Builder] self
+      # @return [ActiveRecord::HierarchicalQuery::Query] self
       def nocycle(value = true)
         @nocycle_value = value
         self
@@ -232,25 +243,26 @@ module ActiveRecord
       #
       # @example
       #   MyModel.join_recursive do |hierarchy|
-      #     hierarchy.connect_by(:id => :parent_id)
-      #              .start_with(:parent_id => nil) { select(:depth) }
+      #     hierarchy.connect_by(id: :parent_id)
+      #              .start_with(parent_id: nil) { select(:depth) }
       #              .select(hierarchy.table[:depth])
       #              .where(hierarchy.prior[:depth].lteq 1)
       #   end
       #
       # @return [Arel::Table]
       def prior
-        @query.recursive_table
+        @recursive_table ||= Arel::Table.new("#{table.name}__recursive")
       end
       alias_method :previous, :prior
+      alias_method :recursive_table, :prior
 
       # Returns object representing child rows table,
       # so it could be used in complex WHEREs.
       #
       # @example
       #   MyModel.join_recursive do |hierarchy|
-      #     hierarchy.connect_by(:id => :parent_id)
-      #              .start_with(:parent_id => nil) { select(:depth) }
+      #     hierarchy.connect_by(id: :parent_id)
+      #              .start_with(parent_id: nil) { select(:depth) }
       #              .select(hierarchy.table[:depth])
       #              .where(hierarchy.prior[:depth].lteq 1)
       #   end
@@ -258,19 +270,37 @@ module ActiveRecord
         @klass.arel_table
       end
 
+      # @return [Arel::Nodes::Node]
+      # @api private
+      def join_conditions
+        connect_by_value.call(recursive_table, table)
+      end
+
+      # @return [ActiveRecord::HierarchicalQuery::Orderings]
+      # @api private
+      def orderings
+        @orderings ||= Orderings.new(order_values, table)
+      end
+
+      # @api private
+      def ordering_column_name
+        ORDERING_COLUMN_NAME
+      end
+
       # Builds recursive query and joins it to given +relation+.
       #
       # @api private
       # @param [ActiveRecord::Relation] relation
       # @param [Hash] join_options
       # @option join_options [#to_s] :as joined table alias
+      # @api private
       def join_to(relation, join_options = {})
         raise 'Recursive query requires CONNECT BY clause, please use #connect_by method' unless
             connect_by_value
 
         table_alias = join_options.fetch(:as, "#{table.name}__recursive")
 
-        JoinBuilder.new(@query, relation, table_alias).build
+        JoinBuilder.new(self, relation, table_alias).build
       end
 
       private