square-arel 2.0.9.20110222133018

data/test/visitors/test_dot.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+module Arel
+  module Visitors
+    class TestDot < MiniTest::Unit::TestCase
+      def setup
+        @visitor = Visitors::Dot.new
+      end
+
+      # unary ops
+      [
+        Arel::Nodes::Not,
+        Arel::Nodes::Group,
+        Arel::Nodes::On,
+        Arel::Nodes::Grouping,
+        Arel::Nodes::Offset,
+        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
+        end
+      end
+    end
+  end
+end

data/test/visitors/test_join_sql.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+module Arel
+  module Visitors
+    describe 'the join_sql visitor' do
+      before do
+        @visitor = JoinSql.new Table.engine
+      end
+
+      describe 'inner join' do
+        it 'should visit left if left is a join' do
+          t    = Table.new :users
+          join = Nodes::InnerJoin.new t, t, Nodes::On.new(t[:id])
+          j2   = Nodes::InnerJoin.new join, t, Nodes::On.new(t[:id])
+          @visitor.accept(j2).must_be_like %{
+            INNER JOIN "users" ON "users"."id"
+            INNER JOIN "users" ON "users"."id"
+          }
+        end
+      end
+
+      describe 'outer join' do
+        it 'should visit left if left is a join' do
+          t    = Table.new :users
+          join = Nodes::OuterJoin.new t, t, Nodes::On.new(t[:id])
+          j2   = Nodes::OuterJoin.new join, t, Nodes::On.new(t[:id])
+          @visitor.accept(j2).must_be_like %{
+            LEFT OUTER JOIN "users" ON "users"."id"
+            LEFT OUTER JOIN "users" ON "users"."id"
+          }
+        end
+      end
+    end
+  end
+end

data/test/visitors/test_mssql.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+module Arel
+  module Visitors
+    describe 'the mssql visitor' do
+      before do
+        @visitor = MSSQL.new Table.engine
+      end
+
+      it 'uses TOP to limit results' do
+        stmt = Nodes::SelectStatement.new
+        stmt.cores.last.top = Nodes::Top.new(1)
+        sql = @visitor.accept(stmt)
+        sql.must_be_like "SELECT TOP 1"
+      end
+    end
+  end
+end

data/test/visitors/test_mysql.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+module Arel
+  module Visitors
+    describe 'the mysql visitor' do
+      before do
+        @visitor = MySQL.new Table.engine
+      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 = @visitor.accept(stmt)
+        sql.must_be_like "SELECT FROM DUAL LIMIT 18446744073709551615 OFFSET 1"
+      end
+
+      it "should escape LIMIT" do
+        sc = Arel::Nodes::UpdateStatement.new
+        sc.limit = Nodes::Limit.new("omg")
+        assert_equal("UPDATE NULL LIMIT 'omg'", @visitor.accept(sc))
+      end
+
+      it 'uses DUAL for empty from' do
+        stmt = Nodes::SelectStatement.new
+        sql = @visitor.accept(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'))
+          @visitor.accept(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'))
+          @visitor.accept(node).must_be_like "LOCK IN SHARE MODE"
+        end
+      end
+    end
+  end
+end

data/test/visitors/test_oracle.rb

@@ -0,0 +1,147 @@
+require 'helper'
+
+module Arel
+  module Visitors
+    describe 'the oracle visitor' do
+      before do
+        @visitor = Oracle.new Table.engine
+      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 = @visitor.accept(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 = @visitor.accept(stmt)
+        sql2 = @visitor.accept(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 = @visitor.accept(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 = @visitor.accept(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 = @visitor.accept 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 = @visitor.accept stmt
+            sql2 = @visitor.accept 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 = @visitor.accept stmt
+            sql.must_be_like %{
+              SELECT * FROM (SELECT ORDER BY foo) WHERE ROWNUM <= 10
+            }
+          end
+
+          it 'creates a subquery when there is DISTINCT' do
+            stmt = Nodes::SelectStatement.new
+            stmt.cores.first.projections << Nodes::SqlLiteral.new('DISTINCT id')
+            stmt.limit = Arel::Nodes::Limit.new(10)
+            sql = @visitor.accept 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(10)
+            stmt.offset = Nodes::Offset.new(10)
+            sql = @visitor.accept 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(10)
+            stmt.offset = Nodes::Offset.new(10)
+            sql = @visitor.accept stmt
+            sql2 = @visitor.accept 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 = @visitor.accept stmt
+            sql.must_be_like %{
+              SELECT * FROM (
+                SELECT raw_sql_.*, rownum raw_rnum_
+                FROM (SELECT ) raw_sql_
+              )
+              WHERE raw_rnum_ > 10
+            }
+          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 = @visitor.accept Nodes::Except.new(left, right)
+          sql.must_be_like %{
+            ( SELECT * FROM users WHERE age > 10 MINUS SELECT * FROM users WHERE age > 20 )
+          }
+        end
+      end
+    end
+  end
+end

data/test/visitors/test_postgres.rb

@@ -0,0 +1,36 @@
+require 'helper'
+
+module Arel
+  module Visitors
+    describe 'the postgres visitor' do
+      before do
+        @visitor = PostgreSQL.new Table.engine
+      end
+
+      describe 'locking' do
+        it 'defaults to FOR UPDATE' do
+          @visitor.accept(Nodes::Lock.new(Arel.sql('FOR UPDATE'))).must_be_like %{
+            FOR UPDATE
+          }
+        end
+
+        it 'allows a custom string to be used as a lock' do
+          node = Nodes::Lock.new(Arel.sql('FOR SHARE'))
+          @visitor.accept(node).must_be_like %{
+            FOR SHARE
+          }
+        end
+      end
+
+      it "should escape LIMIT" do
+        sc = Arel::Nodes::SelectStatement.new
+        sc.limit = Nodes::Limit.new("omg")
+        sc.cores.first.projections << 'DISTINCT ON'
+        sc.orders << "xyz"
+        sql =  @visitor.accept(sc)
+        assert_match(/LIMIT 'omg'/, sql)
+        assert_equal 1, sql.scan(/LIMIT/).length, 'should have one limit'
+      end
+    end
+  end
+end

data/test/visitors/test_sqlite.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+module Arel
+  module Visitors
+    describe 'the sqlite visitor' do
+      before do
+        @visitor = SQLite.new Table.engine
+      end
+
+      it 'defaults limit to -1' do
+        stmt = Nodes::SelectStatement.new
+        stmt.offset = Nodes::Offset.new(1)
+        sql = @visitor.accept(stmt)
+        sql.must_be_like "SELECT LIMIT -1 OFFSET 1"
+      end
+    end
+  end
+end

data/test/visitors/test_to_sql.rb

@@ -0,0 +1,255 @@
+require 'helper'
+
+class Arel::Visitors::ToSql
+  def last_column; Thread.current[:arel_visitors_to_sql_last_column] || @last_column; end
+end
+
+module Arel
+  module Visitors
+    describe 'the to_sql visitor' do
+      before do
+        @visitor = ToSql.new Table.engine
+        @table = Table.new(:users)
+        @attr = @table[:id]
+      end
+
+      it "should be thread safe around usage of last_column" do
+        visit_integer_column = Thread.new do
+          Thread.stop
+          @visitor.send(:visit_Arel_Attributes_Attribute, @attr)
+        end
+
+        @visitor.accept(@table[:name])
+        assert_equal(:string, @visitor.last_column.type)
+        visit_integer_column.run
+        visit_integer_column.join
+        assert_equal(:string, @visitor.last_column.type)
+      end
+
+      describe 'equality' do
+        it 'should handle false' do
+          sql = @visitor.accept Nodes::Equality.new(false, false)
+          sql.must_be_like %{ 'f' = 'f' }
+        end
+
+        it 'should use the column to quote' do
+          table = Table.new(:users)
+          sql = @visitor.accept Nodes::Equality.new(table[:id], '1-fooo')
+          sql.must_be_like %{ "users"."id" = 1 }
+        end
+      end
+
+      it "should visit string subclass" do
+        @visitor.accept(Class.new(String).new(":'("))
+        @visitor.accept(Class.new(Class.new(String)).new(":'("))
+      end
+
+      it "should visit_Class" do
+        @visitor.accept(DateTime).must_equal "'DateTime'"
+      end
+
+      it "should escape LIMIT" do
+        sc = Arel::Nodes::SelectStatement.new
+        sc.limit = Arel::Nodes::Limit.new("omg")
+        assert_match(/LIMIT 'omg'/, @visitor.accept(sc))
+      end
+
+      it "should visit_DateTime" do
+        @visitor.accept DateTime.now
+      end
+
+      it "should visit_Float" do
+        @visitor.accept 2.14
+      end
+
+      it "should visit_Not" do
+        sql = @visitor.accept Nodes::Not.new(Arel.sql("foo"))
+        sql.must_be_like "NOT (foo)"
+      end
+
+      it "should apply Not to the whole expression" do
+        node = Nodes::And.new @attr.eq(10), @attr.eq(11)
+        sql = @visitor.accept Nodes::Not.new(node)
+        sql.must_be_like %{NOT ("users"."id" = 10 AND "users"."id" = 11)}
+      end
+
+      it "should visit_As" do
+        as = Nodes::As.new(Arel.sql("foo"), Arel.sql("bar"))
+        sql = @visitor.accept as
+        sql.must_be_like "foo AS bar"
+      end
+
+      it "should visit_Bignum" do
+        @visitor.accept 8787878092
+      end
+
+      it "should visit_Hash" do
+        @visitor.accept({:a => 1})
+      end
+
+      it "should visit_BigDecimal" do
+        @visitor.accept BigDecimal.new('2.14')
+      end
+
+      it "should visit_Date" do
+        @visitor.accept Date.today
+      end
+
+      it "should visit_NilClass" do
+        @visitor.accept(nil).must_be_like "NULL"
+      end
+
+      it "should visit_Arel_Nodes_And" do
+        node = Nodes::And.new @attr.eq(10), @attr.eq(11)
+        @visitor.accept(node).must_be_like %{
+          "users"."id" = 10 AND "users"."id" = 11
+        }
+      end
+
+      it "should visit_Arel_Nodes_Or" do
+        node = Nodes::Or.new @attr.eq(10), @attr.eq(11)
+        @visitor.accept(node).must_be_like %{
+          "users"."id" = 10 OR "users"."id" = 11
+        }
+      end
+
+      it "should visit visit_Arel_Attributes_Time" do
+        attr = Attributes::Time.new(@attr.relation, @attr.name, @attr.column)
+        @visitor.accept attr
+      end
+
+      it "should visit_TrueClass" do
+        test = Table.new(:users)[:bool].eq(true)
+        @visitor.accept(test).must_be_like %{ "users"."bool" = 't' }
+      end
+
+      describe "Nodes::Ordering" do
+        it "should know how to visit" do
+          node = @attr.desc
+          @visitor.accept(node).must_be_like %{
+            "users"."id" DESC
+          }
+        end
+      end
+
+      describe "Nodes::In" do
+        it "should know how to visit" do
+          node = @attr.in [1, 2, 3]
+          @visitor.accept(node).must_be_like %{
+            "users"."id" IN (1, 2, 3)
+          }
+        end
+
+        it "should turn empty right to NULL" do
+          node = @attr.in []
+          @visitor.accept(node).must_be_like %{
+            "users"."id" IN (NULL)
+          }
+        end
+
+        it 'can handle two dot ranges' do
+          node = @attr.in 1..3
+          @visitor.accept(node).must_be_like %{
+            "users"."id" BETWEEN 1 AND 3
+          }
+        end
+
+        it 'can handle three dot ranges' do
+          node = @attr.in 1...3
+          @visitor.accept(node).must_be_like %{
+            "users"."id" >= 1 AND "users"."id" < 3
+          }
+        end
+
+        it 'can handle subqueries' do
+          table = Table.new(:users)
+          subquery = table.project(:id).where(table[:name].eq('Aaron'))
+          node = @attr.in subquery
+          @visitor.accept(node).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
+          }
+        end
+
+        it 'uses the same column for escaping values' do
+        @attr = Table.new(:users)[:name]
+          visitor = Class.new(ToSql) do
+            attr_accessor :expected
+
+            def quote value, column = nil
+              raise unless column == expected
+              super
+            end
+          end
+          in_node = Nodes::In.new @attr, %w{ a b c }
+          visitor = visitor.new(Table.engine)
+          visitor.expected = @attr.column
+          visitor.accept(in_node).must_equal %("users"."name" IN ('a', 'b', 'c'))
+        end
+      end
+
+      describe "Nodes::NotIn" do
+        it "should know how to visit" do
+          node = @attr.not_in [1, 2, 3]
+          @visitor.accept(node).must_be_like %{
+            "users"."id" NOT IN (1, 2, 3)
+          }
+        end
+
+        it "should turn empty right to NULL" do
+          node = @attr.not_in []
+          @visitor.accept(node).must_be_like %{
+            "users"."id" NOT IN (NULL)
+          }
+        end
+
+        it 'can handle two dot ranges' do
+          node = @attr.not_in 1..3
+          @visitor.accept(node).must_be_like %{
+            "users"."id" < 1 OR "users"."id" > 3
+          }
+        end
+
+        it 'can handle three dot ranges' do
+          node = @attr.not_in 1...3
+          @visitor.accept(node).must_be_like %{
+            "users"."id" < 1 OR "users"."id" >= 3
+          }
+        end
+
+        it 'can handle subqueries' do
+          table = Table.new(:users)
+          subquery = table.project(:id).where(table[:name].eq('Aaron'))
+          node = @attr.not_in subquery
+          @visitor.accept(node).must_be_like %{
+            "users"."id" NOT IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
+          }
+        end
+
+        it 'uses the same column for escaping values' do
+        @attr = Table.new(:users)[:name]
+          visitor = Class.new(ToSql) do
+            attr_accessor :expected
+
+            def quote value, column = nil
+              raise unless column == expected
+              super
+            end
+          end
+          in_node = Nodes::NotIn.new @attr, %w{ a b c }
+          visitor = visitor.new(Table.engine)
+          visitor.expected = @attr.column
+          visitor.accept(in_node).must_equal %("users"."name" NOT IN ('a', 'b', 'c'))
+        end
+      end
+
+      describe 'Equality' do
+        it "should escape strings" do
+          test = Table.new(:users)[:name].eq 'Aaron Patterson'
+          @visitor.accept(test).must_be_like %{
+            "users"."name" = 'Aaron Patterson'
+          }
+        end
+      end
+    end
+  end
+end