arel 1.0.1 → 2.0.0

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

@@ -1,180 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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