arel 6.0.0.beta2 → 6.0.0

data/test/visitors/test_dispatch_contamination.rb

@@ -1,22 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    describe 'avoiding contamination between visitor dispatch tables' do
-      before do
-        @connection = Table.engine.connection
-        @table = Table.new(:users)
-      end
-
-      it 'dispatches properly after failing upwards' do
-        node = Nodes::Union.new(Nodes::True.new, Nodes::False.new)
-        assert_equal "( TRUE UNION FALSE )", node.to_sql
-
-        node.first # from Nodes::Node's Enumerable mixin
-
-        assert_equal "( TRUE UNION FALSE )", node.to_sql
-      end
-    end
-  end
-end
-

data/test/visitors/test_dot.rb

@@ -1,76 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    class TestDot < Minitest::Test
-      def setup
-        @visitor = Visitors::Dot.new
-      end
-
-      # functions
-      [
-        Nodes::Sum,
-        Nodes::Exists,
-        Nodes::Max,
-        Nodes::Min,
-        Nodes::Avg,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          op = klass.new(:a, "z")
-          @visitor.accept op, Collectors::PlainString.new
-        end
-      end
-
-      def test_named_function
-        func = Nodes::NamedFunction.new 'omg', 'omg'
-        @visitor.accept func, Collectors::PlainString.new
-      end
-
-      # unary ops
-      [
-        Arel::Nodes::Not,
-        Arel::Nodes::Group,
-        Arel::Nodes::On,
-        Arel::Nodes::Grouping,
-        Arel::Nodes::Offset,
-        Arel::Nodes::Ordering,
-        Arel::Nodes::Having,
-        Arel::Nodes::UnqualifiedColumn,
-        Arel::Nodes::Top,
-        Arel::Nodes::Limit,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          op = klass.new(:a)
-          @visitor.accept op, Collectors::PlainString.new
-        end
-      end
-
-      # binary ops
-      [
-        Arel::Nodes::Assignment,
-        Arel::Nodes::Between,
-        Arel::Nodes::DoesNotMatch,
-        Arel::Nodes::Equality,
-        Arel::Nodes::GreaterThan,
-        Arel::Nodes::GreaterThanOrEqual,
-        Arel::Nodes::In,
-        Arel::Nodes::LessThan,
-        Arel::Nodes::LessThanOrEqual,
-        Arel::Nodes::Matches,
-        Arel::Nodes::NotEqual,
-        Arel::Nodes::NotIn,
-        Arel::Nodes::Or,
-        Arel::Nodes::TableAlias,
-        Arel::Nodes::Values,
-        Arel::Nodes::As,
-        Arel::Nodes::DeleteStatement,
-        Arel::Nodes::JoinSource,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          binary = klass.new(:a, :b)
-          @visitor.accept binary, Collectors::PlainString.new
-        end
-      end
-    end
-  end
-end

data/test/visitors/test_ibm_db.rb

@@ -1,33 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    describe 'the ibm_db visitor' do
-      before do
-        @visitor = IBM_DB.new Table.engine.connection
-      end
-
-      def compile node
-        @visitor.accept(node, Collectors::SQLString.new).value
-      end
-
-      it 'uses FETCH FIRST n ROWS to limit results' do
-        stmt = Nodes::SelectStatement.new
-        stmt.limit = Nodes::Limit.new(1)
-        sql = compile(stmt)
-        sql.must_be_like "SELECT FETCH FIRST 1 ROWS ONLY"
-      end
-
-      it 'uses FETCH FIRST n ROWS in updates with a limit' do
-        table = Table.new(:users)
-        stmt = Nodes::UpdateStatement.new
-        stmt.relation = table
-        stmt.limit = Nodes::Limit.new(Nodes.build_quoted(1))
-        stmt.key = table[:id]
-        sql = compile(stmt)
-        sql.must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT \"users\".\"id\" FROM \"users\" FETCH FIRST 1 ROWS ONLY)"
-      end
-
-    end
-  end
-end

data/test/visitors/test_informix.rb

@@ -1,58 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    describe 'the informix visitor' do
-      before do
-        @visitor = Informix.new Table.engine.connection
-      end
-
-      def compile node
-        @visitor.accept(node, Collectors::SQLString.new).value
-      end
-
-      it 'uses FIRST n to limit results' do
-        stmt = Nodes::SelectStatement.new
-        stmt.limit = Nodes::Limit.new(1)
-        sql = compile(stmt)
-        sql.must_be_like "SELECT FIRST 1"
-      end
-
-      it 'uses FIRST n in updates with a limit' do
-        table = Table.new(:users)
-        stmt = Nodes::UpdateStatement.new
-        stmt.relation = table
-        stmt.limit = Nodes::Limit.new(Nodes.build_quoted(1))
-        stmt.key = table[:id]
-        sql = compile(stmt)
-        sql.must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT FIRST 1 \"users\".\"id\" FROM \"users\")"
-      end
-
-      it 'uses SKIP n to jump results' do
-        stmt = Nodes::SelectStatement.new
-        stmt.offset = Nodes::Offset.new(10)
-        sql = compile(stmt)
-        sql.must_be_like "SELECT SKIP 10"
-      end
-
-      it 'uses SKIP before FIRST' do
-        stmt = Nodes::SelectStatement.new
-        stmt.limit = Nodes::Limit.new(1)
-        stmt.offset = Nodes::Offset.new(1)
-        sql = compile(stmt)
-        sql.must_be_like "SELECT SKIP 1 FIRST 1"
-      end
-
-      it 'uses INNER JOIN to perform joins' do
-        core = Nodes::SelectCore.new
-        table = Table.new(:posts)
-        core.source = Nodes::JoinSource.new(table, [table.create_join(Table.new(:comments))])
-
-        stmt = Nodes::SelectStatement.new([core])
-        sql = compile(stmt)
-        sql.must_be_like 'SELECT FROM "posts" INNER JOIN "comments"'
-      end
-
-    end
-  end
-end

data/test/visitors/test_mssql.rb

@@ -1,70 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    describe 'the mssql visitor' do
-      before do
-        @visitor = MSSQL.new Table.engine.connection
-        @table = Arel::Table.new "users"
-      end
-
-      def compile node
-        @visitor.accept(node, Collectors::SQLString.new).value
-      end
-
-      it 'should not modify query if no offset or limit' do
-        stmt = Nodes::SelectStatement.new
-        sql = compile(stmt)
-        sql.must_be_like "SELECT"
-      end
-
-      it 'should go over table PK if no .order() or .group()' do
-        stmt = Nodes::SelectStatement.new
-        stmt.cores.first.from = @table
-        stmt.limit = Nodes::Limit.new(10)
-        sql = compile(stmt)
-        sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY \"users\".\"id\") as _row_num FROM \"users\") as _t WHERE _row_num BETWEEN 1 AND 10"
-      end
-
-      it 'should go over query ORDER BY if .order()' do
-        stmt = Nodes::SelectStatement.new
-        stmt.limit = Nodes::Limit.new(10)
-        stmt.orders << Nodes::SqlLiteral.new('order_by')
-        sql = compile(stmt)
-        sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY order_by) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10"
-      end
-
-      it 'should go over query GROUP BY if no .order() and there is .group()' do
-        stmt = Nodes::SelectStatement.new
-        stmt.cores.first.groups << Nodes::SqlLiteral.new('group_by')
-        stmt.limit = Nodes::Limit.new(10)
-        sql = compile(stmt)
-        sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY group_by) as _row_num GROUP BY group_by) as _t WHERE _row_num BETWEEN 1 AND 10"
-      end
-
-      it 'should use BETWEEN if both .limit() and .offset' do
-        stmt = Nodes::SelectStatement.new
-        stmt.limit = Nodes::Limit.new(10)
-        stmt.offset = Nodes::Offset.new(20)
-        sql = compile(stmt)
-        sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 21 AND 30"
-      end
-
-      it 'should use >= if only .offset' do
-        stmt = Nodes::SelectStatement.new
-        stmt.offset = Nodes::Offset.new(20)
-        sql = compile(stmt)
-        sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num >= 21"
-      end
-
-      it 'should generate subquery for .count' do
-        stmt = Nodes::SelectStatement.new
-        stmt.limit = Nodes::Limit.new(10)
-        stmt.cores.first.projections << Nodes::Count.new('*')
-        sql = compile(stmt)
-        sql.must_be_like "SELECT COUNT(1) as count_id FROM (SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10) AS subquery"
-      end
-
-    end
-  end
-end

data/test/visitors/test_mysql.rb

@@ -1,60 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    describe 'the mysql visitor' do
-      before do
-        @visitor = MySQL.new Table.engine.connection
-      end
-
-      def compile node
-        @visitor.accept(node, Collectors::SQLString.new).value
-      end
-
-      it 'squashes parenthesis on multiple unions' do
-        subnode = Nodes::Union.new Arel.sql('left'), Arel.sql('right')
-        node    = Nodes::Union.new subnode, Arel.sql('topright')
-        assert_equal 1, compile(node).scan('(').length
-
-        subnode = Nodes::Union.new Arel.sql('left'), Arel.sql('right')
-        node    = Nodes::Union.new Arel.sql('topleft'), subnode
-        assert_equal 1, compile(node).scan('(').length
-      end
-
-      ###
-      # :'(
-      # http://dev.mysql.com/doc/refman/5.0/en/select.html#id3482214
-      it 'defaults limit to 18446744073709551615' do
-        stmt = Nodes::SelectStatement.new
-        stmt.offset = Nodes::Offset.new(1)
-        sql = compile(stmt)
-        sql.must_be_like "SELECT FROM DUAL LIMIT 18446744073709551615 OFFSET 1"
-      end
-
-      it "should escape LIMIT" do
-        sc = Arel::Nodes::UpdateStatement.new
-        sc.relation = Table.new(:users)
-        sc.limit = Nodes::Limit.new(Nodes.build_quoted("omg"))
-        assert_equal("UPDATE \"users\" LIMIT 'omg'", compile(sc))
-      end
-
-      it 'uses DUAL for empty from' do
-        stmt = Nodes::SelectStatement.new
-        sql = compile(stmt)
-        sql.must_be_like "SELECT FROM DUAL"
-      end
-
-      describe 'locking' do
-        it 'defaults to FOR UPDATE when locking' do
-          node = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
-          compile(node).must_be_like "FOR UPDATE"
-        end
-
-        it 'allows a custom string to be used as a lock' do
-          node = Nodes::Lock.new(Arel.sql('LOCK IN SHARE MODE'))
-          compile(node).must_be_like "LOCK IN SHARE MODE"
-        end
-      end
-    end
-  end
-end

data/test/visitors/test_oracle.rb

@@ -1,170 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    describe 'the oracle visitor' do
-      before do
-        @visitor = Oracle.new Table.engine.connection_pool
-      end
-
-      def compile node
-        @visitor.accept(node, Collectors::SQLString.new).value
-      end
-
-      it 'modifies order when there is distinct and first value' do
-        # *sigh*
-        select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
-        stmt = Nodes::SelectStatement.new
-        stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
-        stmt.orders << Nodes::SqlLiteral.new('foo')
-        sql = compile(stmt)
-        sql.must_be_like %{
-          SELECT #{select} ORDER BY alias_0__
-        }
-      end
-
-      it 'is idempotent with crazy query' do
-        # *sigh*
-        select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
-        stmt = Nodes::SelectStatement.new
-        stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
-        stmt.orders << Nodes::SqlLiteral.new('foo')
-
-        sql = compile(stmt)
-        sql2 = compile(stmt)
-        sql.must_equal sql2
-      end
-
-      it 'splits orders with commas' do
-        # *sigh*
-        select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
-        stmt = Nodes::SelectStatement.new
-        stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
-        stmt.orders << Nodes::SqlLiteral.new('foo, bar')
-        sql = compile(stmt)
-        sql.must_be_like %{
-          SELECT #{select} ORDER BY alias_0__, alias_1__
-        }
-      end
-
-      it 'splits orders with commas and function calls' do
-        # *sigh*
-        select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
-        stmt = Nodes::SelectStatement.new
-        stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
-        stmt.orders << Nodes::SqlLiteral.new('NVL(LOWER(bar, foo), foo) DESC, UPPER(baz)')
-        sql = compile(stmt)
-        sql.must_be_like %{
-          SELECT #{select} ORDER BY alias_0__ DESC, alias_1__
-        }
-      end
-
-      describe 'Nodes::SelectStatement' do
-        describe 'limit' do
-          it 'adds a rownum clause' do
-            stmt = Nodes::SelectStatement.new
-            stmt.limit = Nodes::Limit.new(10)
-            sql = compile stmt
-            sql.must_be_like %{ SELECT WHERE ROWNUM <= 10 }
-          end
-
-          it 'is idempotent' do
-            stmt = Nodes::SelectStatement.new
-            stmt.orders << Nodes::SqlLiteral.new('foo')
-            stmt.limit = Nodes::Limit.new(10)
-            sql = compile stmt
-            sql2 = compile stmt
-            sql.must_equal sql2
-          end
-
-          it 'creates a subquery when there is order_by' do
-            stmt = Nodes::SelectStatement.new
-            stmt.orders << Nodes::SqlLiteral.new('foo')
-            stmt.limit = Nodes::Limit.new(10)
-            sql = compile stmt
-            sql.must_be_like %{
-              SELECT * FROM (SELECT ORDER BY foo ) WHERE ROWNUM <= 10
-            }
-          end
-
-          it 'creates a subquery when there is group by' do
-            stmt = Nodes::SelectStatement.new
-            stmt.cores.first.groups << Nodes::SqlLiteral.new('foo')
-            stmt.limit = Nodes::Limit.new(10)
-            sql = compile stmt
-            sql.must_be_like %{
-              SELECT * FROM (SELECT GROUP BY foo ) WHERE ROWNUM <= 10
-            }
-          end
-
-          it 'creates a subquery when there is DISTINCT' do
-            stmt = Nodes::SelectStatement.new
-            stmt.cores.first.set_quantifier = Arel::Nodes::Distinct.new
-            stmt.cores.first.projections << Nodes::SqlLiteral.new('id')
-            stmt.limit = Arel::Nodes::Limit.new(10)
-            sql = compile stmt
-            sql.must_be_like %{
-              SELECT * FROM (SELECT DISTINCT id ) WHERE ROWNUM <= 10
-            }
-          end
-
-          it 'creates a different subquery when there is an offset' do
-            stmt = Nodes::SelectStatement.new
-            stmt.limit = Nodes::Limit.new(Nodes.build_quoted(10))
-            stmt.offset = Nodes::Offset.new(10)
-            sql = compile stmt
-            sql.must_be_like %{
-              SELECT * FROM (
-                SELECT raw_sql_.*, rownum raw_rnum_
-                FROM (SELECT ) raw_sql_
-                 WHERE rownum <= 20
-              )
-              WHERE raw_rnum_ > 10
-            }
-          end
-
-          it 'is idempotent with different subquery' do
-            stmt = Nodes::SelectStatement.new
-            stmt.limit = Nodes::Limit.new(Nodes.build_quoted(10))
-            stmt.offset = Nodes::Offset.new(10)
-            sql = compile stmt
-            sql2 = compile stmt
-            sql.must_equal sql2
-          end
-        end
-
-        describe 'only offset' do
-          it 'creates a select from subquery with rownum condition' do
-            stmt = Nodes::SelectStatement.new
-            stmt.offset = Nodes::Offset.new(10)
-            sql = compile stmt
-            sql.must_be_like %{
-              SELECT * FROM (
-                SELECT raw_sql_.*, rownum raw_rnum_
-                FROM (SELECT) raw_sql_
-              )
-              WHERE raw_rnum_ > 10
-            }
-          end
-        end
-
-      end
-
-      it 'modified except to be minus' do
-        left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10")
-        right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20")
-        sql = compile Nodes::Except.new(left, right)
-        sql.must_be_like %{
-          ( SELECT * FROM users WHERE age > 10 MINUS SELECT * FROM users WHERE age > 20 )
-        }
-      end
-
-      describe 'locking' do
-        it 'defaults to FOR UPDATE when locking' do
-          node = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
-          compile(node).must_be_like "FOR UPDATE"
-        end
-      end
-    end
-  end
-end