arel 1.0.1 → 2.0.0

data/spec/engines/sql/unit/primitives/literal_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe SqlLiteral do
-    before do
-      @relation = Table.new(:users)
-    end
-
-    describe '#to_sql' do
-      it "manufactures sql with a literal SQL fragment" do
-        sql = @relation.project(Count.new(SqlLiteral.new("*"))).to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{SELECT COUNT(*) AS count_id FROM `users`})
-        end
-
-        adapter_is :oracle do
-          sql.should be_like(%Q{SELECT COUNT(*) AS count_id FROM "USERS"})
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{SELECT COUNT(*) AS count_id FROM "users"})
-        end
-      end
-
-      it "manufactures expressions on literal SQL fragment" do
-        sql = @relation.project(SqlLiteral.new("2 * credit_limit").sum).to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{SELECT SUM(2 * credit_limit) AS sum_id FROM `users`})
-        end
-
-        adapter_is :oracle do
-          sql.should be_like(%Q{SELECT SUM(2 * credit_limit) AS sum_id FROM "USERS"})
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{SELECT SUM(2 * credit_limit) AS sum_id FROM "users"})
-        end
-      end
-    end
-  end
-end

data/spec/engines/sql/unit/primitives/value_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Value do
-    before do
-      @relation = Table.new(:users)
-    end
-
-    describe '#to_sql' do
-      it "appropriately quotes the value" do
-        Value.new(1, @relation).to_sql.should be_like('1')
-
-        adapter_is_not :postgresql do
-          Value.new('asdf', @relation).to_sql.should be_like("'asdf'")
-        end
-
-        adapter_is :postgresql do
-          Value.new('asdf', @relation).to_sql.should be_like("E'asdf'")
-        end
-      end
-    end
-
-    describe '#format' do
-      it "returns the sql of the provided object" do
-        Value.new(1, @relation).format(@relation[:id]).should == @relation[:id].to_sql
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Alias do
-    before do
-      @relation = Table.new(:users)
-    end
-
-    describe '#to_sql' do
-      describe 'when there is no ambiguity' do
-        it 'does not alias table names anywhere a table name can appear' do
-          sql = @relation                 \
-            .where(@relation[:id].eq(1))  \
-            .order(@relation[:id])        \
-            .project(@relation[:id])      \
-            .group(@relation[:id])        \
-            .alias                        \
-          .to_sql
-
-          adapter_is :mysql do
-            sql.should be_like(%Q{
-              SELECT `users`.`id`
-              FROM `users`
-              WHERE `users`.`id` = 1
-              GROUP BY `users`.`id`
-              ORDER BY `users`.`id` ASC
-            })
-          end
-
-          adapter_is :oracle do
-            sql.should be_like(%Q{
-              SELECT "USERS"."ID"
-              FROM "USERS"
-              WHERE "USERS"."ID" = 1
-              GROUP BY "USERS"."ID"
-              ORDER BY "USERS"."ID" ASC
-            })
-          end
-
-          adapter_is_not :mysql, :oracle do
-            sql.should be_like(%Q{
-              SELECT "users"."id"
-              FROM "users"
-              WHERE "users"."id" = 1
-              GROUP BY "users"."id"
-              ORDER BY "users"."id" ASC
-            })
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Deletion do
-    before do
-      @relation = Table.new(:users)
-    end
-
-    describe '#to_sql' do
-      it 'manufactures sql deleting a table relation' do
-        sql = Deletion.new(@relation).to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{DELETE FROM `users`})
-        end
-
-        adapter_is :oracle do
-          sql.should be_like(%Q{DELETE FROM "USERS"})
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{DELETE FROM "users"})
-        end
-      end
-
-      it 'manufactures sql deleting a where relation' do
-        sql = Deletion.new(@relation.where(@relation[:id].eq(1))).to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{
-            DELETE
-            FROM `users`
-            WHERE `users`.`id` = 1
-          })
-        end
-
-        adapter_is :oracle do
-          sql.should be_like(%Q{
-            DELETE
-            FROM "USERS"
-            WHERE "USERS"."ID" = 1
-          })
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{
-            DELETE
-            FROM "users"
-            WHERE "users"."id" = 1
-          })
-        end
-      end
-
-      it "manufactures sql deleting a ranged relation" do
-        sql = Deletion.new(@relation.take(1)).to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{
-            DELETE
-            FROM `users`
-            LIMIT 1
-          })
-        end
-
-        adapter_is :oracle do
-          sql.should be_like(%Q{
-            DELETE
-            FROM "USERS"
-            WHERE ROWNUM <= 1
-          })
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{
-            DELETE
-            FROM "users"
-            LIMIT 1
-          })
-        end
-      end
-    end
-  end
-end

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

@@ -1,64 +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.from("workers").to_sql
-
-        adapter_is :mysql do
-          sql.should be_like(%Q{
-            SELECT `users`.`id`, `users`.`name`
-            FROM workers
-          })
-        end
-
-        adapter_is :oracle do
-          sql.should be_like(%Q{
-            SELECT "USERS"."ID", "USERS"."NAME"
-            FROM workers
-          })
-        end
-
-        adapter_is_not :mysql, :oracle do
-          sql.should be_like(%Q{
-            SELECT "users"."id", "users"."name"
-            FROM workers
-          })
-        end
-      end
-    end
-
-    describe '#to_sql' do
-      it "overrides and use last from clause given " do
-        sql = @relation.from("workers").from("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
-
-  end
-end

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

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

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

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Having do
-    before do
-      @relation = Table.new(:developers)
-    end
-
-    describe '#to_sql' do
-      describe 'when given a predicate' do
-        it "manufactures sql with where clause conditions" do
-          sql = @relation.group(@relation[:department]).having("MIN(salary) > 1000").to_sql
-
-          adapter_is :mysql do
-            sql.should be_like(%Q{
-              SELECT `developers`.`id`, `developers`.`name`, `developers`.`salary`, `developers`.`department`, `developers`.`created_at`
-              FROM `developers`
-              GROUP BY `developers`.`department`
-              HAVING MIN(salary) > 1000
-            })
-          end
-
-          adapter_is :oracle do
-            sql.should be_like(%Q{
-              SELECT "DEVELOPERS"."ID", "DEVELOPERS"."NAME", "DEVELOPERS"."SALARY", "DEVELOPERS"."DEPARTMENT", "DEVELOPERS"."CREATED_AT"
-              FROM "DEVELOPERS"
-              GROUP BY "DEVELOPERS"."DEPARTMENT"
-              HAVING MIN(salary) > 1000
-            })
-          end
-
-          adapter_is_not :mysql, :oracle do
-            sql.should be_like(%Q{
-              SELECT "developers"."id", "developers"."name", "developers"."salary", "developers"."department", "developers"."created_at"
-              FROM "developers"
-              GROUP BY "developers"."department"
-              HAVING MIN(salary) > 1000
-            })
-          end
-        end
-      end
-
-      describe 'when given two predicates' do
-        it "manufactures sql with where clause conditions joined by AND" do
-          sql = @relation.group(@relation[:department]).having("MIN(salary) > 1000", "MAX(salary) < 10000").to_sql
-
-          adapter_is :mysql do
-            sql.should be_like(%Q{
-              SELECT `developers`.`id`, `developers`.`name`, `developers`.`salary`, `developers`.`department`, `developers`.`created_at`
-              FROM `developers`
-              GROUP BY `developers`.`department`
-              HAVING MIN(salary) > 1000 AND MAX(salary) < 10000
-            })
-          end
-
-          adapter_is :oracle do
-            sql.should be_like(%Q{
-              SELECT "DEVELOPERS"."ID", "DEVELOPERS"."NAME", "DEVELOPERS"."SALARY", "DEVELOPERS"."DEPARTMENT", "DEVELOPERS"."CREATED_AT"
-              FROM "DEVELOPERS"
-              GROUP BY "DEVELOPERS"."DEPARTMENT"
-              HAVING MIN(salary) > 1000 AND MAX(salary) < 10000
-            })
-          end
-
-          adapter_is_not :mysql, :oracle do
-            sql.should be_like(%Q{
-              SELECT "developers"."id", "developers"."name", "developers"."salary", "developers"."department", "developers"."created_at"
-              FROM "developers"
-              GROUP BY "developers"."department"
-              HAVING MIN(salary) > 1000 AND MAX(salary) < 10000
-            })
-          end
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,143 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Insert do
-    before do
-      @relation = Table.new(:users)
-    end
-
-    describe '#to_sql' do
-      it 'manufactures sql inserting data when given multiple rows' do
-        pending 'it should insert multiple rows' do
-          @insertion = Insert.new(@relation, [@relation[:name] => "nick", @relation[:name] => "bryan"])
-
-          @insertion.to_sql.should be_like("
-            INSERT
-            INTO `users`
-            (`name`) VALUES ('nick'), ('bryan')
-          ")
-        end
-      end
-
-      it 'manufactures sql inserting data when given multiple values' do
-        @insertion = Insert.new(@relation, @relation[:id] => "1", @relation[:name] => "nick")
-
-        adapter_is :mysql do
-          @insertion.to_sql.should be_like(%Q{
-            INSERT
-            INTO `users`
-            (`id`, `name`) VALUES (1, 'nick')
-          })
-        end
-
-        adapter_is :sqlite3 do
-          @insertion.to_sql.should be_like(%Q{
-            INSERT
-            INTO "users"
-            ("id", "name") VALUES (1, 'nick')
-          })
-        end
-
-        adapter_is :postgresql do
-          @insertion.to_sql.should be_like(%Q{
-            INSERT
-            INTO "users"
-            ("id", "name") VALUES (1, E'nick')
-            RETURNING "id"
-          })
-        end
-
-        adapter_is :oracle do
-          @insertion.to_sql.should be_like(%Q{
-            INSERT
-            INTO "USERS"
-            ("ID", "NAME") VALUES (1, 'nick')
-          })
-        end
-      end
-
-      describe 'when given values whose types correspond to the types of the attributes' do
-        before do
-          @insertion = Insert.new(@relation, @relation[:name] => "nick")
-        end
-
-        it 'manufactures sql inserting data' do
-          adapter_is :mysql do
-            @insertion.to_sql.should be_like(%Q{
-              INSERT
-              INTO `users`
-              (`name`) VALUES ('nick')
-            })
-          end
-
-          adapter_is :sqlite3 do
-            @insertion.to_sql.should be_like(%Q{
-              INSERT
-              INTO "users"
-              ("name") VALUES ('nick')
-            })
-          end
-
-          adapter_is :postgresql do
-            @insertion.to_sql.should be_like(%Q{
-              INSERT
-              INTO "users"
-              ("name") VALUES (E'nick')
-              RETURNING "id"
-            })
-          end
-
-          adapter_is :oracle do
-            @insertion.to_sql.should be_like(%Q{
-              INSERT
-              INTO "USERS"
-              ("NAME") VALUES ('nick')
-            })
-          end
-        end
-      end
-
-      describe 'when given values whose types differ from from the types of the attributes' do
-        before do
-          @insertion = Insert.new(@relation, @relation[:id] => '1-asdf')
-        end
-
-        it 'manufactures sql inserting data' do
-          adapter_is :mysql do
-            @insertion.to_sql.should be_like(%Q{
-              INSERT
-              INTO `users`
-              (`id`) VALUES (1)
-            })
-          end
-
-          adapter_is :sqlite3 do
-            @insertion.to_sql.should be_like(%Q{
-              INSERT
-              INTO "users"
-              ("id") VALUES (1)
-            })
-          end
-
-          adapter_is :postgresql do
-            @insertion.to_sql.should be_like(%Q{
-              INSERT
-              INTO "users"
-              ("id") VALUES (1)
-              RETURNING "id"
-            })
-          end
-
-          adapter_is :oracle do
-            @insertion.to_sql.should be_like(%Q{
-              INSERT
-              INTO "USERS"
-              ("ID") VALUES (1)
-            })
-          end
-
-        end
-      end
-    end
-  end
-end