arel 1.0.1 → 2.0.0

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

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Skip do
-    before do
-      @relation = Table.new(:users)
-      @skipped = 4
-    end
-
-    describe '#to_sql' do
-      it "manufactures sql with limit and offset" do
-        sql = Skip.new(@relation, @skipped).to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{
-            SELECT `users`.`id`, `users`.`name`
-            FROM `users`
-            OFFSET 4
-          })
-        end
-
-        adapter_is :oracle do
-          sql.should be_like(%Q{
-            select * from (select raw_sql_.*, rownum raw_rnum_ from
-            (SELECT "USERS"."ID", "USERS"."NAME"
-            FROM "USERS") raw_sql_)
-            where raw_rnum_ > 4
-          })
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{
-            SELECT "users"."id", "users"."name"
-            FROM "users"
-            OFFSET 4
-          })
-        end
-      end
-    end
-  end
-end

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

@@ -1,122 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Table do
-    before do
-      @relation = Table.new(:users)
-    end
-
-    describe '#to_sql' do
-      it "manufactures a simple select query" do
-        sql = @relation.to_sql
-
-        adapter_is :mysql 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"
-          })
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{
-            SELECT "users"."id", "users"."name"
-            FROM "users"
-          })
-        end
-      end
-    end
-
-    describe '#as' do
-      it "manufactures a simple select query using aliases" do
-        sql = @relation.as(:super_users).to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{
-            SELECT `super_users`.`id`, `super_users`.`name`
-            FROM `users` `super_users`
-          })
-        end
-
-        adapter_is :oracle do
-          sql.should be_like(%Q{
-            SELECT "SUPER_USERS"."ID", "SUPER_USERS"."NAME"
-            FROM "USERS" "SUPER_USERS"
-          })
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{
-            SELECT "super_users"."id", "super_users"."name"
-            FROM "users" "super_users"
-          })
-        end
-      end
-
-      it "does not apply alias if it's same as the table name" do
-        sql = @relation.as(:users).to_sql
-
-        adapter_is :mysql 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"
-          })
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{
-            SELECT "users"."id", "users"."name"
-            FROM "users"
-          })
-        end
-      end
-
-    end
-
-    describe '#column_for' do
-      it "returns the column corresponding to the attribute" do
-        @relation.column_for(@relation[:id]).should == @relation.columns.detect { |c| c.name == 'id' }
-      end
-    end
-
-    describe '#attributes' do
-      it 'manufactures attributes corresponding to columns in the table' do
-        @relation.attributes.should == [
-          Attribute.new(@relation, :id),
-          Attribute.new(@relation, :name)
-        ]
-      end
-
-      describe '#reset' do
-        it "reloads columns from the database" do
-          lambda { @relation.engine.stub!(:columns => []) }.should_not change { @relation.attributes }
-          lambda { @relation.reset                        }.should     change { @relation.attributes }
-        end
-      end
-    end
-
-    describe '#engine' do
-      it "defaults to global engine" do
-        Table.engine = engine = Sql::Engine.new
-        Table.new(:users).engine.should == engine
-      end
-
-      it "can be specified" do
-        Table.new(:users, engine = Sql::Engine.new).engine.should == engine
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Take do
-    before do
-      @relation = Table.new(:users)
-      @taken = 4
-    end
-
-    describe '#to_sql' do
-      it "manufactures sql with limit and offset" do
-        sql = Take.new(@relation, @taken).to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{
-            SELECT `users`.`id`, `users`.`name`
-            FROM `users`
-            LIMIT 4
-          })
-        end
-
-        adapter_is :oracle do
-          sql.should be_like(%Q{
-            SELECT "USERS"."ID", "USERS"."NAME"
-            FROM "USERS"
-            WHERE ROWNUM <= 4
-          })
-
-          sql_with_order_by = Take.new(@relation.order(@relation[:id]), @taken).to_sql
-          sql_with_order_by.should be_like(%Q{
-            select * from
-            (SELECT "USERS"."ID", "USERS"."NAME"
-            FROM "USERS"
-            ORDER BY "USERS"."ID" ASC)
-            where rownum <= 4
-          })
-
-          sql_with_distinct = Take.new(@relation.project('DISTINCT "USERS"."ID"'), @taken).to_sql
-          sql_with_distinct.should be_like(%Q{
-            select * from
-            (SELECT DISTINCT "USERS"."ID"
-            FROM "USERS")
-            where rownum <= 4
-          })
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{
-            SELECT "users"."id", "users"."name"
-            FROM "users"
-            LIMIT 4
-          })
-        end
-      end
-
-      it "manufactures count sql with limit" do
-        sql = Take.new(@relation.project(@relation[:id].count), @taken).to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{
-            SELECT COUNT(*) AS count_id
-            FROM (SELECT 1 FROM `users` LIMIT 4) AS subquery
-          })
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{
-            SELECT COUNT(*) AS count_id
-            FROM (SELECT 1 FROM "users" LIMIT 4) AS subquery
-          })
-        end
-      end
-    end
-  end
-end

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

@@ -1,203 +0,0 @@
-require 'spec_helper'
-
-class User
-  def self.primary_key
-    "id"
-  end
-end
-
-module Arel
-  describe Update do
-    before do
-      @relation = Table.new(:users)
-    end
-
-    describe '#to_sql' do
-      it "manufactures sql updating attributes when given multiple attributes" do
-        sql = Update.new(@relation, @relation[:id] => 1, @relation[:name] => "nick").to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{
-            UPDATE `users`
-            SET `id` = 1, `name` = 'nick'
-          })
-        end
-
-        adapter_is :sqlite3 do
-          sql.should be_like(%Q{
-            UPDATE "users"
-            SET "id" = 1, "name" = 'nick'
-          })
-        end
-
-        adapter_is :postgresql do
-          sql.should be_like(%Q{
-            UPDATE "users"
-            SET "id" = 1, "name" = E'nick'
-          })
-        end
-
-        adapter_is :oracle do
-          sql.should be_like(%Q{
-            UPDATE "USERS"
-            SET "ID" = 1, "NAME" = 'nick'
-          })
-        end
-      end
-
-      it "manufactures sql updating attributes when given a ranged relation" do
-        sql = Update.new(@relation.take(1), @relation[:name] => "nick").to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{
-            UPDATE `users`
-            SET `name` = 'nick'
-            LIMIT 1
-          })
-        end
-
-        adapter_is :sqlite3 do
-          sql.should be_like(%Q{
-            UPDATE "users" SET
-            "name" = 'nick'
-            WHERE "id" IN (SELECT "id" FROM "users"  LIMIT 1)
-          })
-        end
-
-        adapter_is :postgresql do
-          sql.should be_like(%Q{
-            UPDATE "users" SET
-            "name" = E'nick'
-            WHERE "id" IN (SELECT "id" FROM "users"  LIMIT 1)
-          })
-        end
-
-        adapter_is :oracle do
-          sql.should be_like(%Q{
-            UPDATE "USERS" SET
-            "NAME" = 'nick'
-            WHERE "ID" IN (SELECT "ID" FROM "USERS" WHERE ROWNUM <= 1)
-          })
-
-          sql_with_order_by = Update.new(@relation.order(@relation[:id]).take(1), @relation[:name] => "nick").to_sql
-          sql_with_order_by.should be_like(%Q{
-            UPDATE "USERS" SET
-            "NAME" = 'nick'
-            WHERE "ID" IN (select * from
-                          (SELECT "ID" FROM "USERS" ORDER BY "USERS"."ID" ASC)
-                          where rownum <= 1)
-          })
-        end
-      end
-
-      describe 'when given values whose types correspond to the types of the attributes' do
-        before do
-          @update = Update.new(@relation, @relation[:name] => "nick")
-        end
-
-        it 'manufactures sql updating attributes' do
-          adapter_is :mysql do
-            @update.to_sql.should be_like(%Q{
-              UPDATE `users`
-              SET `name` = 'nick'
-            })
-          end
-
-          adapter_is :sqlite3 do
-            @update.to_sql.should be_like(%Q{
-              UPDATE "users"
-              SET "name" = 'nick'
-            })
-          end
-
-          adapter_is :postgresql do
-            @update.to_sql.should be_like(%Q{
-              UPDATE "users"
-              SET "name" = E'nick'
-            })
-          end
-
-          adapter_is :oracle do
-            @update.to_sql.should be_like(%Q{
-              UPDATE "USERS"
-              SET "NAME" = 'nick'
-            })
-          end
-        end
-      end
-
-      describe 'when given values whose types differ from from the types of the attributes' do
-        before do
-          @update = Update.new(@relation, @relation[:id] => '1-asdf')
-        end
-
-        it 'manufactures sql updating attributes' do
-          adapter_is :mysql do
-            @update.to_sql.should be_like(%Q{
-              UPDATE `users`
-              SET `id` = 1
-            })
-          end
-
-          adapter_is :oracle do
-            @update.to_sql.should be_like(%Q{
-              UPDATE "USERS"
-              SET "ID" = 1
-            })
-          end
-
-          adapter_is_not :mysql, :oracle do
-            @update.to_sql.should be_like(%Q{
-              UPDATE "users"
-              SET "id" = 1
-            })
-          end
-        end
-      end
-
-      describe 'when the relation is a where' do
-        before do
-          @update = Update.new(
-            @relation.where(@relation[:id].eq(1)),
-            @relation[:name] => "nick"
-          )
-        end
-
-        it 'manufactures sql updating a where relation' do
-          adapter_is :mysql do
-            @update.to_sql.should be_like(%Q{
-              UPDATE `users`
-              SET `name` = 'nick'
-              WHERE `users`.`id` = 1
-            })
-          end
-
-          adapter_is :sqlite3 do
-            @update.to_sql.should be_like(%Q{
-              UPDATE "users"
-              SET "name" = 'nick'
-              WHERE "users"."id" = 1
-            })
-          end
-
-          adapter_is :postgresql do
-            @update.to_sql.should be_like(%Q{
-              UPDATE "users"
-              SET "name" = E'nick'
-              WHERE "users"."id" = 1
-            })
-          end
-
-          adapter_is :oracle do
-            @update.to_sql.should be_like(%Q{
-              UPDATE "USERS"
-              SET "NAME" = 'nick'
-              WHERE "USERS"."ID" = 1
-            })
-          end
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Where do
-    before do
-      @relation = Table.new(:users)
-      @predicate = @relation[:id].eq(1)
-    end
-
-    describe '#to_sql' do
-      describe 'when given a predicate' do
-        it "manufactures sql with where clause conditions" do
-          sql = Where.new(@relation, [@predicate]).to_sql
-
-          adapter_is :mysql do
-            sql.should be_like(%Q{
-              SELECT `users`.`id`, `users`.`name`
-              FROM `users`
-              WHERE `users`.`id` = 1
-            })
-          end
-
-          adapter_is :oracle do
-            sql.should be_like(%Q{
-              SELECT "USERS"."ID", "USERS"."NAME"
-              FROM "USERS"
-              WHERE "USERS"."ID" = 1
-            })
-          end
-
-          adapter_is_not :mysql, :oracle do
-            sql.should be_like(%Q{
-              SELECT "users"."id", "users"."name"
-              FROM "users"
-              WHERE "users"."id" = 1
-            })
-          end
-        end
-      end
-
-      describe 'when given a string' do
-        it "passes the string through to the where clause" do
-          sql = Where.new(@relation, 'asdf').to_sql
-
-          adapter_is :mysql do
-            sql.should be_like(%Q{
-              SELECT `users`.`id`, `users`.`name`
-              FROM `users`
-              WHERE asdf
-            })
-          end
-
-          adapter_is :oracle do
-            sql.should be_like(%Q{
-              SELECT "USERS"."ID", "USERS"."NAME"
-              FROM "USERS"
-              WHERE asdf
-            })
-          end
-
-          adapter_is_not :mysql, :oracle do
-            sql.should be_like(%Q{
-              SELECT "users"."id", "users"."name"
-              FROM "users"
-              WHERE asdf
-            })
-          end
-        end
-      end
-    end
-  end
-end