activerecord-hierarchical_query 0.0.2 → 0.0.5

data/lib/active_record/hierarchical_query/adapters.rb

@@ -1,34 +0,0 @@
-# coding: utf-8
-
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/string/inflections'
-
-module ActiveRecord
-  module HierarchicalQuery
-    module Adapters
-      SUPPORTED_ADAPTERS = %w(PostgreSQL)
-
-      ADAPTERS = Hash[
-        :PostgreSQL => :PostgreSQL,
-        :PostGIS => :PostgreSQL,
-        :OracleEnhanced => :Oracle
-      ].stringify_keys
-
-      def self.autoload(name, path = name.to_s.underscore)
-        super name, "active_record/hierarchical_query/adapters/#{path}"
-      end
-
-      autoload :PostgreSQL, 'postgresql'
-      autoload :Oracle
-
-      def self.lookup(klass)
-        name = klass.connection.adapter_name
-
-        raise 'Your database %s does not support recursive queries' % name unless
-            ADAPTERS.key?(name)
-
-        const_get(ADAPTERS[name])
-      end
-    end # module Adapters
-  end # module HierarchicalQuery
-end # module ActiveRecord

data/lib/active_record/hierarchical_query/adapters/abstract.rb

@@ -1,41 +0,0 @@
-# coding: utf-8
-
-require 'active_record/hierarchical_query/visitors/visitor'
-
-module ActiveRecord
-  module HierarchicalQuery
-    module Adapters
-      # @api private
-      class Abstract
-        attr_reader :query,
-                    :table
-
-        delegate :klass, :to => :query
-
-        class << self
-          def visitors(*visitors_classes)
-            define_method :visitors do
-              @visitors ||= visitors_classes.map { |klass| klass.new(@query) }
-            end
-          end
-        end
-
-        # @param [ActiveRecord::HierarchicalQuery::CTE::Query] query
-        def initialize(query)
-          @query = query
-          @table = klass.arel_table
-        end
-
-        # @example
-        #   visit(:recursive_term, recursive_term.arel)
-        def visit(kind, object)
-          method_name = "visit_#{kind}"
-
-          visitors.reduce(object) do |*, visitor|
-            visitor.send(method_name, object) if visitor.respond_to?(method_name)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/hierarchical_query/adapters/postgresql.rb

@@ -1,19 +0,0 @@
-# coding: utf-8
-
-require 'arel/nodes/postgresql'
-
-require 'active_record/hierarchical_query/adapters/abstract'
-require 'active_record/hierarchical_query/visitors/postgresql/cycle_detector'
-require 'active_record/hierarchical_query/visitors/postgresql/orderings'
-
-module ActiveRecord
-  module HierarchicalQuery
-    module Adapters
-      # @api private
-      class PostgreSQL < Abstract
-        visitors Visitors::PostgreSQL::CycleDetector,
-                 Visitors::PostgreSQL::Orderings
-      end # class PostgreSQL
-    end # module Adapters
-  end # module HierarchicalQuery
-end # module ActiveRecord

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

@@ -1,65 +0,0 @@
-# coding: utf-8
-
-require 'active_record/hierarchical_query/adapters'
-require 'active_record/hierarchical_query/cte/columns'
-require 'active_record/hierarchical_query/cte/union_term'
-
-module ActiveRecord
-  module HierarchicalQuery
-    module CTE
-      # CTE query builder
-      class Query
-        attr_reader :builder,
-                    :adapter,
-                    :columns
-
-        delegate :klass, :table, :to => :builder
-
-        # @param [ActiveRecord::HierarchicalQuery::Builder] builder
-        def initialize(builder)
-          @builder = builder
-          @adapter = Adapters.lookup(klass).new(self)
-          @columns = Columns.new(self)
-        end
-
-        # @return [Arel::SelectManager]
-        def arel
-          adapter.visit(:cte, 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
-
-        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 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
-      end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-module ActiveRecord
-  module HierarchicalQuery
-    module Visitors
-      class Orderings < Visitor
-        ORDERING_COLUMN_ALIAS = '__order_column'
-
-        delegate :recursive_table, :to => :query
-
-        def visit_joined_relation(relation)
-          visit(relation) do
-            relation.order(order_clause)
-          end
-        end
-
-        def visit_cte(select_manager)
-          if should_order_cte?
-            select_manager.order(order_clause)
-          else
-            select_manager
-          end
-        end
-
-        protected
-        def visit(object)
-          if orderings.any?
-            yield
-          else
-            object
-          end
-        end
-
-        def order_clause
-          recursive_table[column_name].asc
-        end
-
-        def should_order_cte?
-          orderings.any? && builder.limit_value || builder.offset_value
-        end
-
-        def orderings
-          @orderings ||= builder.order_values.each_with_object([]) do |value, orderings|
-            orderings.concat Array.wrap(as_orderings(value))
-          end
-        end
-
-        def column_name
-          ORDERING_COLUMN_ALIAS
-        end
-
-        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
-      end
-    end
-  end
-end

data/lib/active_record/hierarchical_query/visitors/postgresql/cycle_detector.rb

@@ -1,49 +0,0 @@
-module ActiveRecord
-  module HierarchicalQuery
-    module Visitors
-      module PostgreSQL
-        class CycleDetector < Visitor
-          COLUMN_NAME = '__path'.freeze
-
-          def visit_non_recursive(arel)
-            if enabled?
-              arel.project Arel::Nodes::PostgresArray.new([primary_key]).as(column_name)
-            end
-
-            arel
-          end
-
-          def visit_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?
-            builder.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
-end

data/lib/active_record/hierarchical_query/visitors/postgresql/orderings.rb

@@ -1,70 +0,0 @@
-require 'active_record/hierarchical_query/visitors/orderings'
-
-module ActiveRecord
-  module HierarchicalQuery
-    module Visitors
-      module PostgreSQL
-        class Orderings < Visitors::Orderings
-          NATURAL_SORT_TYPES = Set[
-              :integer, :float, :decimal,
-              :datetime, :timestamp, :time, :date,
-              :boolean, :itet, :cidr, :ltree
-          ]
-
-          delegate :first, :to => :orderings
-
-          def visit_non_recursive(arel)
-            project(arel) do
-              Arel::Nodes::PostgresArray.new([row_number_expression]).as(column_name)
-            end
-          end
-
-          def visit_recursive(arel)
-            project(arel) do
-              Arel::Nodes::ArrayConcat.new(recursive_table[column_name], row_number_expression)
-            end
-          end
-
-          private
-          def project(arel)
-            visit(arel) { arel.project(yield) }
-          end
-
-          def row_number_expression
-            if raw_ordering?
-              order_attribute
-            else
-              Arel.sql("ROW_NUMBER() OVER (ORDER BY #{orderings.map(&:to_sql).join(', ')})")
-            end
-          end
-
-          def raw_ordering?
-            ordered_by_attribute? &&
-                (column = order_column) &&
-                NATURAL_SORT_TYPES.include?(column.type)
-          end
-
-          def ordered_by_attribute?
-            orderings.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
-  end
-end

data/lib/active_record/hierarchical_query/visitors/visitor.rb

@@ -1,17 +0,0 @@
-module ActiveRecord
-  module HierarchicalQuery
-    module Visitors
-      # @api private
-      class Visitor
-        attr_reader :query
-
-        delegate :builder, :to => :query
-        delegate :klass, :table, :to => :builder
-
-        def initialize(query)
-          @query = query
-        end
-      end
-    end
-  end
-end