arel-compat 0.4.0

data/spec/engines/sql/unit/relations/join_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+module Arel
+  describe Join do
+    before do
+      @relation1 = Table.new(:users)
+      @relation2 = Table.new(:photos)
+      @predicate1 = @relation1[:id].eq(@relation2[:user_id])
+
+      @relation3 = Table.new(:users, :as => :super_users)
+      @relation4 = Table.new(:photos, :as => :super_photos)
+
+      @predicate2 = @relation3[:id].eq(@relation2[:user_id])
+      @predicate3 = @relation3[:id].eq(@relation4[:user_id])
+    end
+
+    describe '#to_sql' do
+
+      describe 'when joining with another relation' do
+        it 'manufactures sql joining the two tables on the predicate' do
+          sql = InnerJoin.new(@relation1, @relation2, @predicate1).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT `users`.`id`, `users`.`name`, `photos`.`id`, `photos`.`user_id`, `photos`.`camera_id`
+              FROM `users`
+                INNER JOIN `photos` ON `users`.`id` = `photos`.`user_id`
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT "USERS"."ID", "USERS"."NAME", "PHOTOS"."ID", "PHOTOS"."USER_ID", "PHOTOS"."CAMERA_ID"
+              FROM "USERS"
+                INNER JOIN "PHOTOS" ON "USERS"."ID" = "PHOTOS"."USER_ID"
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT "users"."id", "users"."name", "photos"."id", "photos"."user_id", "photos"."camera_id"
+              FROM "users"
+                INNER JOIN "photos" ON "users"."id" = "photos"."user_id"
+            })
+          end
+        end
+
+        describe 'when joining with another relation with an aliased table' do
+          it 'manufactures sql joining the two tables on the predicate respecting table aliasing' do
+            sql = InnerJoin.new(@relation3, @relation2, @predicate2).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{
+                SELECT `super_users`.`id`, `super_users`.`name`, `photos`.`id`, `photos`.`user_id`, `photos`.`camera_id`
+                FROM `users` `super_users`
+                  INNER JOIN `photos` ON `super_users`.`id` = `photos`.`user_id`
+              })
+            end
+
+            adapter_is :oracle do
+              sql.should be_like(%Q{
+                SELECT "SUPER_USERS"."ID", "SUPER_USERS"."NAME", "PHOTOS"."ID", "PHOTOS"."USER_ID", "PHOTOS"."CAMERA_ID"
+                FROM "USERS" "SUPER_USERS"
+                  INNER JOIN "PHOTOS" ON "SUPER_USERS"."ID" = "PHOTOS"."USER_ID"
+              })
+            end
+
+            adapter_is_not :mysql, :oracle do
+              sql.should be_like(%Q{
+                SELECT "super_users"."id", "super_users"."name", "photos"."id", "photos"."user_id", "photos"."camera_id"
+                FROM "users" "super_users"
+                  INNER JOIN "photos" ON "super_users"."id" = "photos"."user_id"
+              })
+            end
+          end
+        end
+
+        describe 'when joining with two relations with aliased tables' do
+          it 'manufactures sql joining the two tables on the predicate respecting table aliasing' do
+            sql = InnerJoin.new(@relation3, @relation4, @predicate3).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{
+                SELECT `super_users`.`id`, `super_users`.`name`, `super_photos`.`id`, `super_photos`.`user_id`, `super_photos`.`camera_id`
+                FROM `users` `super_users`
+                  INNER JOIN `photos` `super_photos` ON `super_users`.`id` = `super_photos`.`user_id`
+              })
+            end
+
+            adapter_is :oracle do
+              sql.should be_like(%Q{
+                SELECT "SUPER_USERS"."ID", "SUPER_USERS"."NAME", "SUPER_PHOTOS"."ID", "SUPER_PHOTOS"."USER_ID", "SUPER_PHOTOS"."CAMERA_ID"
+                FROM "USERS" "SUPER_USERS"
+                  INNER JOIN "PHOTOS" "SUPER_PHOTOS" ON "SUPER_USERS"."ID" = "SUPER_PHOTOS"."USER_ID"
+              })
+            end
+
+            adapter_is_not :mysql, :oracle do
+              sql.should be_like(%Q{
+                SELECT "super_users"."id", "super_users"."name", "super_photos"."id", "super_photos"."user_id", "super_photos"."camera_id"
+                FROM "users" "super_users"
+                  INNER JOIN "photos" "super_photos" ON "super_users"."id" = "super_photos"."user_id"
+              })
+            end
+          end
+        end
+
+      end
+
+      describe 'when joining with a string' do
+        it "passes the string through to the where clause" do
+          sql = StringJoin.new(@relation1, "INNER JOIN asdf ON fdsa").to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT `users`.`id`, `users`.`name`
+              FROM `users`
+                INNER JOIN asdf ON fdsa
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT "USERS"."ID", "USERS"."NAME"
+              FROM "USERS"
+                INNER JOIN asdf ON fdsa
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT "users"."id", "users"."name"
+              FROM "users"
+                INNER JOIN asdf ON fdsa
+            })
+          end
+        end
+
+        it "passes the string when there are multiple string joins" do
+          relation = StringJoin.new(@relation1, "INNER JOIN asdf ON fdsa")
+          relation = StringJoin.new(relation, "INNER JOIN lifo ON fifo")
+          sql = StringJoin.new(relation, "INNER JOIN hatful ON hallow").to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT `users`.`id`, `users`.`name`
+              FROM `users`
+                INNER JOIN asdf ON fdsa
+                INNER JOIN lifo ON fifo
+                INNER JOIN hatful ON hallow
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT "USERS"."ID", "USERS"."NAME"
+              FROM "USERS"
+                INNER JOIN asdf ON fdsa
+                INNER JOIN lifo ON fifo
+                INNER JOIN hatful ON hallow
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT "users"."id", "users"."name"
+              FROM "users"
+                INNER JOIN asdf ON fdsa
+                INNER JOIN lifo ON fifo
+                INNER JOIN hatful ON hallow
+            })
+          end
+        end
+
+    end
+
+
+    end
+  end
+end

data/spec/engines/sql/unit/relations/lock_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+module Arel
+  describe Lock do
+    before do
+      @relation = Table.new(:users)
+    end
+
+    describe '#to_sql' do
+      it "manufactures a simple select query lock" do
+        sql = @relation.lock.to_sql
+
+        adapter_is :mysql do
+          sql.should be_like(%Q{
+            SELECT `users`.`id`, `users`.`name`
+            FROM `users` FOR UPDATE
+          })
+        end
+
+        adapter_is :postgresql do
+          sql.should be_like(%Q{
+            SELECT "users"."id", "users"."name"
+            FROM "users" FOR UPDATE
+          })
+        end
+
+        adapter_is :sqlite3 do
+          sql.should be_like(%Q{
+            SELECT "users"."id", "users"."name"
+            FROM "users"
+          })
+        end
+
+        adapter_is :oracle do
+          sql.should be_like(%Q{
+            SELECT "USERS"."ID", "USERS"."NAME"
+            FROM "USERS" FOR UPDATE
+          })
+
+          sql_with_order_by = @relation.order(@relation[:id]).take(1).lock.to_sql
+          sql_with_order_by.should be_like(%Q{
+            SELECT "USERS"."ID", "USERS"."NAME"
+            FROM "USERS"
+            WHERE "ID" IN (select * from
+                          (SELECT "ID" FROM "USERS" ORDER BY "USERS"."ID" ASC)
+                          where rownum <= 1)
+            FOR UPDATE
+          })
+
+        end
+      end
+
+      it "manufactures a select query locking with a given lock" do
+        sql = @relation.lock("LOCK IN SHARE MODE").to_sql
+
+        adapter_is :mysql do
+          sql.should be_like(%Q{
+            SELECT `users`.`id`, `users`.`name`
+            FROM `users` LOCK IN SHARE MODE
+          })
+        end
+
+        adapter_is :postgresql do
+          sql.should be_like(%Q{
+            SELECT "users"."id", "users"."name"
+            FROM "users" LOCK IN SHARE MODE
+          })
+        end
+
+        adapter_is :sqlite3 do
+          sql.should be_like(%Q{
+            SELECT "users"."id", "users"."name"
+            FROM "users"
+          })
+        end
+
+        adapter_is :oracle do
+          sql.should be_like(%Q{
+            SELECT "USERS"."ID", "USERS"."NAME"
+            FROM "USERS" LOCK IN SHARE MODE
+          })
+        end
+      end
+    end
+  end
+end

data/spec/engines/sql/unit/relations/order_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+module Arel
+  describe Order do
+    before do
+      @relation = Table.new(:users)
+      @attribute = @relation[:id]
+    end
+
+    describe '#to_sql' do
+      describe "when given an attribute" do
+        it "manufactures sql with an order clause populated by the attribute" do
+          sql = Order.new(@relation, @attribute).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT `users`.`id`, `users`.`name`
+              FROM `users`
+              ORDER BY `users`.`id` ASC
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT "USERS"."ID", "USERS"."NAME"
+              FROM "USERS"
+              ORDER BY "USERS"."ID" ASC
+            })
+
+            distinct_attributes = ActiveRecord::Base.connection.distinct('"USERS"."NAME"', '"USERS"."ID"')
+            @relation.project(distinct_attributes).order(@relation[:id]).to_sql.should be_like(%Q{
+              SELECT DISTINCT "USERS"."NAME",
+              FIRST_VALUE("USERS"."ID") OVER (PARTITION BY "USERS"."NAME" ORDER BY "USERS"."ID") AS alias_0__
+              FROM "USERS"
+              ORDER BY alias_0__
+            })
+
+            distinct_attributes = ActiveRecord::Base.connection.distinct('"USERS"."NAME"', '"USERS"."ID" DESC')
+            @relation.project(distinct_attributes).order('"USERS"."ID" DESC').to_sql.should be_like(%Q{
+              SELECT DISTINCT "USERS"."NAME",
+              FIRST_VALUE("USERS"."ID") OVER (PARTITION BY "USERS"."NAME" ORDER BY "USERS"."ID" DESC) AS alias_0__
+              FROM "USERS"
+              ORDER BY alias_0__ DESC
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT "users"."id", "users"."name"
+              FROM "users"
+              ORDER BY "users"."id" ASC
+            })
+          end
+        end
+      end
+
+      describe "when given multiple attributes" do
+        before do
+          @another_attribute = @relation[:name]
+        end
+
+        it "manufactures sql with an order clause populated by comma-separated attributes" do
+          sql = Order.new(@relation, @attribute, @another_attribute).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT `users`.`id`, `users`.`name`
+              FROM `users`
+              ORDER BY `users`.`id` ASC, `users`.`name` ASC
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT "USERS"."ID", "USERS"."NAME"
+              FROM "USERS"
+              ORDER BY "USERS"."ID" ASC, "USERS"."NAME" ASC
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT "users"."id", "users"."name"
+              FROM "users"
+              ORDER BY "users"."id" ASC, "users"."name" ASC
+            })
+          end
+        end
+      end
+
+      describe "when given a string" do
+        before do
+          @string = "asdf"
+        end
+
+        it "passes the string through to the order clause" do
+          sql = Order.new(@relation, @string).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT `users`.`id`, `users`.`name`
+              FROM `users`
+              ORDER BY asdf
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT "USERS"."ID", "USERS"."NAME"
+              FROM "USERS"
+              ORDER BY asdf
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT "users"."id", "users"."name"
+              FROM "users"
+              ORDER BY asdf
+            })
+          end
+        end
+      end
+
+      describe "when ordering an ordered relation" do
+        before do
+          @ordered_relation = Order.new(@relation, @attribute)
+          @another_attribute = @relation[:name]
+        end
+
+        it "manufactures sql with the order clause of the last ordering preceding the first ordering" do
+          sql = Order.new(@ordered_relation, @another_attribute).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT `users`.`id`, `users`.`name`
+              FROM `users`
+              ORDER BY `users`.`name` ASC, `users`.`id` ASC
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT "USERS"."ID", "USERS"."NAME"
+              FROM "USERS"
+              ORDER BY "USERS"."NAME" ASC, "USERS"."ID" ASC
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT "users"."id", "users"."name"
+              FROM "users"
+              ORDER BY "users"."name" ASC, "users"."id" ASC
+            })
+          end
+        end
+      end
+    end
+  end
+end

data/spec/engines/sql/unit/relations/project_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+module Arel
+  describe Project do
+    before do
+      @relation = Table.new(:users)
+      @attribute = @relation[:id]
+    end
+
+    describe '#to_sql' do
+      describe 'when given an attribute' do
+        it "manufactures sql with a limited select clause" do
+          sql = Project.new(@relation, @attribute).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT `users`.`id`
+              FROM `users`
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT "USERS"."ID"
+              FROM "USERS"
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT "users"."id"
+              FROM "users"
+            })
+          end
+        end
+      end
+
+      describe 'when given a relation' do
+        before do
+          @scalar_relation = Project.new(@relation, @relation[:name])
+        end
+
+        it "manufactures sql with scalar selects" do
+          sql = Project.new(@relation, @scalar_relation).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT (SELECT `users`.`name` FROM `users`) AS `users` FROM `users`
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT (SELECT "USERS"."NAME" FROM "USERS") AS "USERS" FROM "USERS"
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT (SELECT "users"."name" FROM "users") AS "users" FROM "users"
+            })
+          end
+        end
+      end
+
+      describe 'when given a string' do
+        it "passes the string through to the select clause" do
+          sql = Project.new(@relation, 'asdf').to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT asdf FROM `users`
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT asdf FROM "USERS"
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT asdf FROM "users"
+            })
+          end
+        end
+      end
+
+      describe 'when given an expression' do
+        it 'manufactures sql with expressions' do
+          sql = @relation.project(@attribute.count).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT COUNT(`users`.`id`) AS count_id
+              FROM `users`
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT COUNT("USERS"."ID") AS count_id
+              FROM "USERS"
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT COUNT("users"."id") AS count_id
+              FROM "users"
+            })
+          end
+        end
+
+        it 'manufactures sql with distinct expressions' do
+          sql = @relation.project(@attribute.count(true)).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT COUNT(DISTINCT `users`.`id`) AS count_id
+              FROM `users`
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT COUNT(DISTINCT "USERS"."ID") AS count_id
+              FROM "USERS"
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT COUNT(DISTINCT "users"."id") AS count_id
+              FROM "users"
+            })
+          end
+        end
+      end
+    end
+  end
+end