activerecord-hierarchical_query 0.0.1

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

@@ -0,0 +1,28 @@
+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::Query] query
+        def initialize(query)
+          @query = query
+        end
+
+        def arel
+          non_recursive_term.union(:all, recursive_term)
+        end
+
+        private
+        def recursive_term
+          RecursiveTerm.new(@query).arel
+        end
+
+        def non_recursive_term
+          NonRecursiveTerm.new(@query).arel
+        end
+      end
+    end
+  end
+end

data/lib/active_record/hierarchical_query/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module HierarchicalQuery
+    VERSION = '0.0.1'
+  end
+end

data/lib/arel/nodes/postgresql.rb

@@ -0,0 +1,28 @@
+module Arel
+  module Nodes
+    class PostgresArray < Node
+      include AliasPredication
+      attr_accessor :values
+
+      def initialize(values)
+        self.values = values
+      end
+    end
+
+    class ArrayConcat < Binary
+    end
+  end
+
+  module Visitors
+    class ToSql < Arel::Visitors::Visitor
+      private
+      def visit_Arel_Nodes_PostgresArray o, *a
+        "ARRAY[#{visit o.values, *a}]"
+      end
+
+      def visit_Arel_Nodes_ArrayConcat o, *a
+        "#{visit o.left, *a} || #{visit o.right, *a}"
+      end
+    end
+  end
+end

data/spec/active_record/hierarchical_query_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe ActiveRecord::HierarchicalQuery do
+  let(:klass) { Category }
+
+  let!(:root) { klass.create }
+  let!(:child_1) { klass.create(:parent => root) }
+  let!(:child_2) { klass.create(:parent => child_1) }
+  let!(:child_3) { klass.create(:parent => child_1) }
+  let!(:child_4) { klass.create(:parent => root) }
+  let!(:child_5) { klass.create(:parent => child_4) }
+
+  describe '#join_recursive' do
+    describe 'CONNECT BY clause' do
+      it 'throws error if CONNECT BY clause not specified' do
+        expect {
+          klass.join_recursive {}
+        }.to raise_error /CONNECT BY clause/
+      end
+
+      it 'joins parent and child rows by hash map' do
+        expect(
+          klass.join_recursive { connect_by(:id => :parent_id) }
+        ).to include root, child_1, child_2, child_3, child_4, child_5
+      end
+
+      it 'joins parent and child rows by block' do
+        expect(
+          klass.join_recursive do
+            connect_by { |parent, child| parent[:id].eq child[:parent_id] }
+          end
+        ).to include root, child_1, child_2, child_3, child_4, child_5
+      end
+    end
+
+    describe 'START WITH clause' do
+      def assert_start_with(&block)
+        expect(
+          klass.join_recursive do |b|
+            b.connect_by(:id => :parent_id).instance_eval(&block)
+          end
+        ).to match_array [root, child_1, child_2, child_3, child_4, child_5]
+      end
+
+      it 'filters rows in non-recursive term by hash' do
+        assert_start_with { start_with(:parent_id => nil) }
+      end
+
+      it 'filters rows in non-recursive term by block with arity > 0' do
+        assert_start_with { start_with { |root| root.where(:parent_id => nil) } }
+      end
+
+      it 'filters rows in non-recursive term by block with arity = 0' do
+        assert_start_with { start_with { where(:parent_id => nil) } }
+      end
+
+      it 'filters rows in non-recursive term by scope' do
+        assert_start_with { start_with(klass.where(:parent_id => nil)) }
+      end
+    end
+
+    describe 'ORDER SIBLINGS BY clause' do
+      def assert_ordered_by_name_desc(&block)
+        expect(
+          klass.join_recursive do |b|
+            b.connect_by(:id => :parent_id).start_with(:parent_id => nil).instance_eval(&block)
+          end
+        ).to eq [root, child_4, child_5, child_1, child_3, child_2]
+      end
+
+      def assert_ordered_by_name_asc(&block)
+        expect(
+            klass.join_recursive do |b|
+              b.connect_by(:id => :parent_id).start_with(:parent_id => nil).instance_eval(&block)
+            end
+        ).to eq [root, child_1, child_2, child_3, child_4, child_5]
+      end
+
+      it 'orders rows by Hash' do
+        assert_ordered_by_name_desc { order_siblings(:name => :desc) }
+      end
+
+      it 'orders rows by String' do
+        assert_ordered_by_name_desc { order_siblings('name desc') }
+        assert_ordered_by_name_asc { order_siblings('name asc') }
+      end
+
+      it 'orders rows by Arel::Nodes::Ordering' do
+        assert_ordered_by_name_desc { order_siblings(table[:name].desc) }
+      end
+
+      it 'orders rows by Arel::Nodes::Node' do
+        assert_ordered_by_name_asc { order_siblings(table[:name]) }
+      end
+
+      it 'throws error when something weird given' do
+        expect {
+          klass.join_recursive { connect_by(:id => :parent_id).order_siblings(1) }
+        }.to raise_error /ORDER BY SIBLINGS/
+      end
+
+      context 'when one attribute given and this attribute support natural sorting' do
+        let(:relation) do
+          klass.join_recursive do
+            connect_by(:id => :parent_id).
+            start_with(:parent_id => nil).
+            order_siblings(:position)
+          end
+        end
+
+        it 'orders rows by given attribute' do
+          expect(relation).to eq [root, child_1, child_2, child_3, child_4, child_5]
+          expect(relation.to_sql).not_to match /row_number/i
+        end
+      end
+    end
+
+    describe 'LIMIT and OFFSET clauses' do
+      let(:ordered_nodes) { [root, child_1, child_2, child_3, child_4, child_5] }
+
+      it 'limits all rows' do
+        expect(
+          klass.join_recursive do
+            connect_by(:id => :parent_id).
+            start_with(:parent_id => nil).
+            order_siblings(:name).
+            limit(2).
+            offset(2)
+          end
+        ).to eq ordered_nodes[2...4]
+      end
+    end
+
+    describe 'WHERE clause' do
+      it 'filters child rows' do
+        expect(
+          klass.join_recursive do
+            connect_by(:id => :parent_id).
+            start_with(:parent_id => nil).
+            where('depth < ?', 2)
+          end
+        ).to match_array [root, child_1, child_4]
+      end
+
+      it 'allows to use PRIOR relation' do
+        expect(
+          klass.join_recursive do |b|
+            b.connect_by(:id => :parent_id)
+             .start_with(:parent_id => nil)
+             .select(:depth)
+             .where(b.prior[:depth].lt(1))
+          end
+        ).to match_array [root, child_1, child_4]
+      end
+    end
+
+    describe 'SELECT clause' do
+      it 'adds column to both recursive and non-recursive term' do
+        expect(
+          klass.join_recursive(:as => 'categories_r') do
+            connect_by(:id => :parent_id).
+            start_with(:parent_id => nil).
+            select(:depth)
+          end.where('categories_r.depth = 0')
+        ).to eq [root]
+      end
+    end
+
+    describe 'NOCYCLE clause' do
+      before { klass.where(:id => child_4.id).update_all(:parent_id => child_5.id) }
+
+      it 'prevents recursive query from endless loops' do
+        expect(
+          klass.join_recursive do |query|
+            query.start_with(:id => child_4.id)
+                 .connect_by(:id => :parent_id)
+                 .nocycle
+          end
+        ).to match_array [child_4, child_5]
+      end
+    end
+  end
+
+  describe '#join_recursive options' do
+    describe ':as option' do
+      it 'builds a join with specified alias' do
+        expect(
+          klass.join_recursive(:as => 'my_table') { connect_by(:id => :parent_id) }.to_sql
+        ).to match /my_table/
+      end
+    end
+  end
+end

data/spec/database.travis.yml

@@ -0,0 +1,4 @@
+adapter: postgresql
+database: hierarchical_query_test
+username: postgres
+min_messages: ERROR

data/spec/database.yml

@@ -0,0 +1,4 @@
+adapter: postgresql
+database: hierarchical_query_test
+username: vagrant
+min_messages: ERROR

data/spec/schema.rb

@@ -0,0 +1,10 @@
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :categories, :force => true do |t|
+    t.column :parent_id, :integer
+    t.column :name, :string
+    t.column :depth, :integer
+    t.column :position, :integer
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+require 'pathname'
+require 'logger'
+
+SPEC_ROOT = Pathname.new(File.dirname(__FILE__))
+
+require 'bundler/setup'
+
+Bundler.setup(:default, ENV['TRAVIS'] ? :travis : :local)
+
+require 'rspec'
+require 'database_cleaner'
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(YAML.load(SPEC_ROOT.join('database.yml').read))
+ActiveRecord::Base.logger = Logger.new(ENV['DEBUG'] ? $stderr : '/dev/null')
+ActiveRecord::Base.logger.formatter = proc do |severity, datetime, progname, msg|
+  "#{datetime.strftime('%H:%M:%S.%L')}: #{msg}\n"
+end
+
+load SPEC_ROOT.join('schema.rb')
+require SPEC_ROOT.join('support', 'models').to_s
+
+DatabaseCleaner.strategy = :transaction
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.start
+    example.run
+    DatabaseCleaner.clean
+  end
+end
+
+if ENV['TRAVIS']
+  require 'coveralls'
+  Coveralls.wear!
+else
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'active_record/hierarchical_query'

data/spec/support/models.rb

@@ -0,0 +1,39 @@
+class Category < ActiveRecord::Base
+  @@generator = Enumerator.new do |y|
+    abc = ('a'..'z').to_a
+    sequence = abc.product(abc, abc).map(&:join).to_enum
+
+    loop do
+      # category aaa
+      # category aab
+      # ...
+      # category aaz
+      # category aba
+      # ...
+      y << "category #{sequence.next}"
+    end
+  end
+
+  belongs_to :parent, :class_name => 'Category'
+  has_many :children, :class_name => 'Category'
+
+  before_save :generate_name, :unless => :name?
+  before_save :count_depth
+  before_save :count_position
+
+  def generate_name
+    self.name = @@generator.next
+  end
+
+  def count_depth
+    self.depth = ancestors.count
+  end
+
+  def count_position
+    self.position = (self.class.where(:parent_id => parent_id).maximum(:position) || 0) + 1
+  end
+
+  def ancestors
+    parent ? parent.ancestors + [parent] : []
+  end
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-hierarchical_query
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alexei Mikhailov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.17.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.17.1
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+description: 
+email:
+- amikhailov83@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_record/hierarchical_query.rb
+- lib/active_record/hierarchical_query/adapters.rb
+- lib/active_record/hierarchical_query/adapters/postgresql.rb
+- lib/active_record/hierarchical_query/builder.rb
+- lib/active_record/hierarchical_query/cte/columns.rb
+- lib/active_record/hierarchical_query/cte/cycle_detector.rb
+- lib/active_record/hierarchical_query/cte/join_builder.rb
+- lib/active_record/hierarchical_query/cte/non_recursive_term.rb
+- lib/active_record/hierarchical_query/cte/orderings.rb
+- lib/active_record/hierarchical_query/cte/query.rb
+- lib/active_record/hierarchical_query/cte/recursive_term.rb
+- lib/active_record/hierarchical_query/cte/union_term.rb
+- lib/active_record/hierarchical_query/version.rb
+- lib/arel/nodes/postgresql.rb
+- spec/active_record/hierarchical_query_spec.rb
+- spec/database.travis.yml
+- spec/database.yml
+- spec/schema.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- README.md
+- LICENSE.txt
+homepage: https://github.com/take-five/activerecord-hierarchical_query
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: Recursively traverse trees using a single SQL query
+test_files:
+- spec/active_record/hierarchical_query_spec.rb
+- spec/database.travis.yml
+- spec/database.yml
+- spec/schema.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+has_rdoc: