arel 1.0.1 → 2.0.0

data/spec/engines/sql/integration/joins/with_aggregations_spec.rb

@@ -1,221 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Join do
-    before do
-      @relation1 = Table(:users)
-      @relation2 = Table(:photos)
-      @predicate = @relation1[:id].eq(@relation2[:user_id])
-    end
-
-    describe 'when joining aggregated relations' do
-      before do
-        @aggregation = @relation2                                           \
-          .group(@relation2[:user_id])                                      \
-          .project(@relation2[:user_id], @relation2[:id].count.as(:cnt))    \
-      end
-
-      describe '#to_sql' do
-        # CLEANUP
-        it '' do
-          sql = @relation1.join(@relation2.take(3)).on(@predicate).to_sql
-
-          adapter_is :mysql do
-            sql.should be_like(%Q{
-              SELECT `users`.`id`, `users`.`name`, `photos_external`.`id`, `photos_external`.`user_id`, `photos_external`.`camera_id`
-              FROM `users`
-              INNER JOIN (SELECT `photos`.`id`, `photos`.`user_id`, `photos`.`camera_id` FROM `photos` LIMIT 3) `photos_external`
-                ON `users`.`id` = `photos_external`.`user_id`
-            })
-          end
-
-          adapter_is :oracle do
-            sql.should be_like(%Q{
-              SELECT "USERS"."ID", "USERS"."NAME", "PHOTOS_EXTERNAL"."ID", "PHOTOS_EXTERNAL"."USER_ID", "PHOTOS_EXTERNAL"."CAMERA_ID"
-              FROM "USERS"
-              INNER JOIN (SELECT "PHOTOS"."ID", "PHOTOS"."USER_ID", "PHOTOS"."CAMERA_ID" FROM "PHOTOS" WHERE ROWNUM <= 3) "PHOTOS_EXTERNAL"
-                ON "USERS"."ID" = "PHOTOS_EXTERNAL"."USER_ID"
-            })
-          end
-
-          adapter_is_not :mysql, :oracle do
-            sql.should be_like(%Q{
-              SELECT "users"."id", "users"."name", "photos_external"."id", "photos_external"."user_id", "photos_external"."camera_id"
-              FROM "users"
-              INNER JOIN (SELECT "photos"."id", "photos"."user_id", "photos"."camera_id" FROM "photos" LIMIT 3) "photos_external"
-                ON "users"."id" = "photos_external"."user_id"
-            })
-          end
-        end
-
-        describe 'with the aggregation on the right' do
-          it 'manufactures sql joining the left table to a derived table' do
-            sql = @relation1.join(@aggregation).on(@predicate).to_sql
-
-            adapter_is :mysql do
-              sql.should be_like(%Q{
-                SELECT `users`.`id`, `users`.`name`, `photos_external`.`user_id`, `photos_external`.`cnt`
-                FROM `users`
-                  INNER JOIN (SELECT `photos`.`user_id`, COUNT(`photos`.`id`) AS `cnt` FROM `photos` GROUP BY `photos`.`user_id`) `photos_external`
-                    ON `users`.`id` = `photos_external`.`user_id`
-              })
-            end
-
-            adapter_is :oracle do
-              sql.should be_like(%Q{
-                SELECT "USERS"."ID", "USERS"."NAME", "PHOTOS_EXTERNAL"."USER_ID", "PHOTOS_EXTERNAL"."CNT"
-                FROM "USERS"
-                  INNER JOIN (SELECT "PHOTOS"."USER_ID", COUNT("PHOTOS"."ID") AS "CNT" FROM "PHOTOS" GROUP BY "PHOTOS"."USER_ID") "PHOTOS_EXTERNAL"
-                    ON "USERS"."ID" = "PHOTOS_EXTERNAL"."USER_ID"
-              })
-            end
-
-            adapter_is_not :mysql, :oracle do
-              sql.should be_like(%Q{
-                SELECT "users"."id", "users"."name", "photos_external"."user_id", "photos_external"."cnt"
-                FROM "users"
-                  INNER JOIN (SELECT "photos"."user_id", COUNT("photos"."id") AS "cnt" FROM "photos" GROUP BY "photos"."user_id") "photos_external"
-                    ON "users"."id" = "photos_external"."user_id"
-              })
-            end
-          end
-        end
-
-        describe 'with the aggregation on the left' do
-          it 'manufactures sql joining the right table to a derived table' do
-            sql = @aggregation.join(@relation1).on(@predicate).to_sql
-
-            adapter_is :mysql do
-              sql.should be_like(%Q{
-                SELECT `photos_external`.`user_id`, `photos_external`.`cnt`, `users`.`id`, `users`.`name`
-                FROM (SELECT `photos`.`user_id`, COUNT(`photos`.`id`) AS `cnt` FROM `photos` GROUP BY `photos`.`user_id`) `photos_external`
-                  INNER JOIN `users`
-                    ON `users`.`id` = `photos_external`.`user_id`
-              })
-            end
-
-            adapter_is :oracle do
-              sql.should be_like(%Q{
-                SELECT "PHOTOS_EXTERNAL"."USER_ID", "PHOTOS_EXTERNAL"."CNT", "USERS"."ID", "USERS"."NAME"
-                FROM (SELECT "PHOTOS"."USER_ID", COUNT("PHOTOS"."ID") AS "CNT" FROM "PHOTOS" GROUP BY "PHOTOS"."USER_ID") "PHOTOS_EXTERNAL"
-                  INNER JOIN "USERS"
-                    ON "USERS"."ID" = "PHOTOS_EXTERNAL"."USER_ID"
-              })
-            end
-
-            adapter_is_not :mysql, :oracle do
-              sql.should be_like(%Q{
-                SELECT "photos_external"."user_id", "photos_external"."cnt", "users"."id", "users"."name"
-                FROM (SELECT "photos"."user_id", COUNT("photos"."id") AS "cnt" FROM "photos" GROUP BY "photos"."user_id") "photos_external"
-                  INNER JOIN "users"
-                    ON "users"."id" = "photos_external"."user_id"
-              })
-            end
-          end
-        end
-
-        describe 'with the aggregation on both sides' do
-          it 'it properly aliases the aggregations' do
-            aggregation2 = @aggregation.alias
-            sql = @aggregation.join(aggregation2).on(aggregation2[:user_id].eq(@aggregation[:user_id])).to_sql
-
-            adapter_is :mysql do
-              sql.should be_like(%Q{
-                SELECT `photos_external`.`user_id`, `photos_external`.`cnt`, `photos_external_2`.`user_id`, `photos_external_2`.`cnt`
-                FROM (SELECT `photos`.`user_id`, COUNT(`photos`.`id`) AS `cnt` FROM `photos` GROUP BY  `photos`.`user_id`) `photos_external`
-                  INNER JOIN (SELECT `photos`.`user_id`, COUNT(`photos`.`id`) AS `cnt` FROM `photos` GROUP BY `photos`.`user_id`) `photos_external_2`
-                    ON `photos_external_2`.`user_id` = `photos_external`.`user_id`
-              })
-            end
-
-            adapter_is :oracle do
-              sql.should be_like(%Q{
-                SELECT "PHOTOS_EXTERNAL"."USER_ID", "PHOTOS_EXTERNAL"."CNT", "PHOTOS_EXTERNAL_2"."USER_ID", "PHOTOS_EXTERNAL_2"."CNT"
-                FROM (SELECT "PHOTOS"."USER_ID", COUNT("PHOTOS"."ID") AS "CNT" FROM "PHOTOS" GROUP BY  "PHOTOS"."USER_ID") "PHOTOS_EXTERNAL"
-                  INNER JOIN (SELECT "PHOTOS"."USER_ID", COUNT("PHOTOS"."ID") AS "CNT" FROM "PHOTOS" GROUP BY "PHOTOS"."USER_ID") "PHOTOS_EXTERNAL_2"
-                    ON "PHOTOS_EXTERNAL_2"."USER_ID" = "PHOTOS_EXTERNAL"."USER_ID"
-              })
-            end
-
-            adapter_is_not :mysql, :oracle do
-              sql.should be_like(%Q{
-                SELECT "photos_external"."user_id", "photos_external"."cnt", "photos_external_2"."user_id", "photos_external_2"."cnt"
-                FROM (SELECT "photos"."user_id", COUNT("photos"."id") AS "cnt" FROM "photos" GROUP BY  "photos"."user_id") "photos_external"
-                  INNER JOIN (SELECT "photos"."user_id", COUNT("photos"."id") AS "cnt" FROM "photos" GROUP BY "photos"."user_id") "photos_external_2"
-                    ON "photos_external_2"."user_id" = "photos_external"."user_id"
-              })
-            end
-          end
-        end
-
-        describe 'when the aggration has a where' do
-          describe 'with the aggregation on the left' do
-            it "manufactures sql keeping wheres on the aggregation within the derived table" do
-              sql = @relation1.join(@aggregation.where(@aggregation[:user_id].eq(1))).on(@predicate).to_sql
-
-              adapter_is :mysql do
-                sql.should be_like(%Q{
-                  SELECT `users`.`id`, `users`.`name`, `photos_external`.`user_id`, `photos_external`.`cnt`
-                  FROM `users`
-                    INNER JOIN (SELECT `photos`.`user_id`, COUNT(`photos`.`id`) AS `cnt` FROM `photos` WHERE `photos`.`user_id` = 1 GROUP BY `photos`.`user_id`) `photos_external`
-                      ON `users`.`id` = `photos_external`.`user_id`
-                })
-              end
-
-              adapter_is :oracle do
-                sql.should be_like(%Q{
-                  SELECT "USERS"."ID", "USERS"."NAME", "PHOTOS_EXTERNAL"."USER_ID", "PHOTOS_EXTERNAL"."CNT"
-                  FROM "USERS"
-                    INNER JOIN (SELECT "PHOTOS"."USER_ID", COUNT("PHOTOS"."ID") AS "CNT" FROM "PHOTOS" WHERE "PHOTOS"."USER_ID" = 1 GROUP BY "PHOTOS"."USER_ID") "PHOTOS_EXTERNAL"
-                      ON "USERS"."ID" = "PHOTOS_EXTERNAL"."USER_ID"
-                })
-              end
-
-              adapter_is_not :mysql, :oracle do
-                sql.should be_like(%Q{
-                  SELECT "users"."id", "users"."name", "photos_external"."user_id", "photos_external"."cnt"
-                  FROM "users"
-                    INNER JOIN (SELECT "photos"."user_id", COUNT("photos"."id") AS "cnt" FROM "photos" WHERE "photos"."user_id" = 1 GROUP BY "photos"."user_id") "photos_external"
-                      ON "users"."id" = "photos_external"."user_id"
-                })
-              end
-            end
-          end
-
-          describe 'with the aggregation on the right' do
-            it "manufactures sql keeping wheres on the aggregation within the derived table" do
-              sql = @aggregation.where(@aggregation[:user_id].eq(1)).join(@relation1).on(@predicate).to_sql
-
-              adapter_is :mysql do
-                sql.should be_like(%Q{
-                  SELECT `photos_external`.`user_id`, `photos_external`.`cnt`, `users`.`id`, `users`.`name`
-                  FROM (SELECT `photos`.`user_id`, COUNT(`photos`.`id`) AS `cnt` FROM `photos` WHERE `photos`.`user_id` = 1 GROUP BY `photos`.`user_id`) `photos_external`
-                    INNER JOIN `users`
-                      ON `users`.`id` = `photos_external`.`user_id`
-                })
-              end
-
-              adapter_is :oracle do
-                sql.should be_like(%Q{
-                  SELECT "PHOTOS_EXTERNAL"."USER_ID", "PHOTOS_EXTERNAL"."CNT", "USERS"."ID", "USERS"."NAME"
-                  FROM (SELECT "PHOTOS"."USER_ID", COUNT("PHOTOS"."ID") AS "CNT" FROM "PHOTOS" WHERE "PHOTOS"."USER_ID" = 1 GROUP BY "PHOTOS"."USER_ID") "PHOTOS_EXTERNAL"
-                    INNER JOIN "USERS"
-                      ON "USERS"."ID" = "PHOTOS_EXTERNAL"."USER_ID"
-                })
-              end
-
-              adapter_is_not :mysql, :oracle do
-                sql.should be_like(%Q{
-                  SELECT "photos_external"."user_id", "photos_external"."cnt", "users"."id", "users"."name"
-                  FROM (SELECT "photos"."user_id", COUNT("photos"."id") AS "cnt" FROM "photos" WHERE "photos"."user_id" = 1 GROUP BY "photos"."user_id") "photos_external"
-                    INNER JOIN "users"
-                      ON "users"."id" = "photos_external"."user_id"
-                })
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/engines/sql/integration/joins/with_compounds_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Join do
-    before do
-      @relation1 = Table(:users)
-      @relation2 = Table(:photos)
-      @predicate = @relation1[:id].eq(@relation2[:user_id])
-    end
-
-    describe '#to_sql' do
-      describe 'when the join contains a where' do
-        describe 'and the where is given a string' do
-          it 'does not escape the string' do
-            sql = @relation1                    \
-              .join(@relation2.where("asdf"))   \
-                .on(@predicate)                 \
-            .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` AND asdf
-              })
-            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" AND asdf
-              })
-            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" AND asdf
-              })
-            end
-          end
-        end
-      end
-
-      describe 'when a compound contains a join' do
-        describe 'and the compound is a where' do
-          it 'manufactures sql disambiguating the tables' do
-            sql = @relation1                  \
-              .where(@relation1[:id].eq(1))   \
-              .join(@relation2)               \
-                .on(@predicate)               \
-              .where(@relation1[:id].eq(1))   \
-            .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`
-                WHERE `users`.`id` = 1
-                  AND `users`.`id` = 1
-              })
-            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"
-                WHERE "USERS"."ID" = 1
-                  AND "USERS"."ID" = 1
-              })
-            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"
-                WHERE "users"."id" = 1
-                  AND "users"."id" = 1
-              })
-            end
-          end
-        end
-
-        describe 'and the compound is a group' do
-          it 'manufactures sql disambiguating the tables' do
-            sql = @relation1          \
-              .join(@relation2)       \
-                .on(@predicate)       \
-              .group(@relation1[:id]) \
-            .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`
-                GROUP BY `users`.`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"
-                GROUP BY "USERS"."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"
-                GROUP BY "users"."id"
-              })
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/engines/sql/unit/engine_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  FakeAR = Struct.new(:connection)
-  class FakeConnection < Struct.new :called
-    def initialize c = []; super; end
-
-    def method_missing name, *args, &block
-      called << [name, args, block]
-    end
-  end
-
-  describe Sql::Engine do
-    before do
-      @users = Table.new(:users)
-      @users.delete
-    end
-
-    describe "method missing" do
-      it "should ask for a connection" do
-        conn   = FakeConnection.new
-        ar     = FakeAR.new conn
-        engine = Arel::Sql::Engine.new ar
-
-        ar.connection = nil
-        lambda { engine.foo }.should raise_error
-      end
-    end
-
-    describe "CRUD" do
-      describe "#create" do
-        it "inserts into the relation" do
-          @users.insert @users[:name] => "Bryan"
-          @users.first[@users[:name]].should == "Bryan"
-        end
-      end
-
-      describe "#read" do
-        it "reads from the relation" do
-          @users.insert @users[:name] => "Bryan"
-
-          @users.each do |row|
-            row[@users[:name]].should == "Bryan"
-          end
-        end
-      end
-
-      describe "#update" do
-        it "updates the relation" do
-          @users.insert @users[:name] => "Nick"
-          @users.update @users[:name] => "Bryan"
-          @users.first[@users[:name]].should == "Bryan"
-        end
-      end
-
-      describe "#delete" do
-        it "deletes from the relation" do
-          @users.insert @users[:name] => "Bryan"
-          @users.delete
-          @users.first.should == nil
-        end
-      end
-    end
-  end
-end

data/spec/engines/sql/unit/predicates/binary_spec.rb

@@ -1,140 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  module Predicates
-    describe Binary do
-      class ConcreteBinary < Binary
-        def predicate_sql
-          "<=>"
-        end
-      end
-
-      before do
-        @relation = Arel::Table.new(:users)
-        @attribute1 = @relation[:id]
-        @attribute2 = @relation[:name]
-      end
-
-      describe "with compound predicates" do
-        before do
-          @operand1 = ConcreteBinary.new(@attribute1, 1)
-          @operand2 = ConcreteBinary.new(@attribute2, "name")
-        end
-
-        describe Or do
-          describe "#to_sql" do
-            it "manufactures sql with an OR operation" do
-              sql = Or.new(@operand1, @operand2).to_sql
-
-              adapter_is :mysql do
-                sql.should be_like(%Q{(`users`.`id` <=> 1 OR `users`.`name` <=> 'name')})
-              end
-
-              adapter_is :postgresql do
-                sql.should be_like(%Q{("users"."id" <=> 1 OR "users"."name" <=> E'name')})
-              end
-
-              adapter_is :sqlite3 do
-                sql.should be_like(%Q{("users"."id" <=> 1 OR "users"."name" <=> 'name')})
-              end
-
-              adapter_is :oracle do
-                sql.should be_like(%Q{("USERS"."ID" <=> 1 OR "USERS"."NAME" <=> 'name')})
-              end
-            end
-          end
-        end
-
-        describe And do
-          describe "#to_sql" do
-            it "manufactures sql with an AND operation" do
-              sql = And.new(@operand1, @operand2).to_sql
-
-              adapter_is :mysql do
-                sql.should be_like(%Q{(`users`.`id` <=> 1 AND `users`.`name` <=> 'name')})
-              end
-
-              adapter_is :sqlite3 do
-                sql.should be_like(%Q{("users"."id" <=> 1 AND "users"."name" <=> 'name')})
-              end
-
-              adapter_is :postgresql do
-                sql.should be_like(%Q{("users"."id" <=> 1 AND "users"."name" <=> E'name')})
-              end
-
-              adapter_is :oracle do
-                sql.should be_like(%Q{("USERS"."ID" <=> 1 AND "USERS"."NAME" <=> 'name')})
-              end
-            end
-          end
-        end
-      end
-
-      describe '#to_sql' do
-        describe 'when relating two attributes' do
-          it 'manufactures sql with a binary operation' do
-            sql = ConcreteBinary.new(@attribute1, @attribute2).to_sql
-
-            adapter_is :mysql do
-              sql.should be_like(%Q{`users`.`id` <=> `users`.`name`})
-            end
-
-            adapter_is :oracle do
-              sql.should be_like(%Q{"USERS"."ID" <=> "USERS"."NAME"})
-            end
-
-            adapter_is_not :mysql, :oracle do
-              sql.should be_like(%Q{"users"."id" <=> "users"."name"})
-            end
-          end
-        end
-
-        describe 'when relating an attribute and a value' do
-          before do
-            @value = "1-asdf"
-          end
-
-          describe 'when relating to an integer attribute' do
-            it 'formats values as integers' do
-              sql = ConcreteBinary.new(@attribute1, @value).to_sql
-
-              adapter_is :mysql do
-                sql.should be_like(%Q{`users`.`id` <=> 1})
-              end
-
-              adapter_is :oracle do
-                sql.should be_like(%Q{"USERS"."ID" <=> 1})
-              end
-
-              adapter_is_not :mysql, :oracle do
-                sql.should be_like(%Q{"users"."id" <=> 1})
-              end
-            end
-          end
-
-          describe 'when relating to a string attribute' do
-            it 'formats values as strings' do
-              sql = ConcreteBinary.new(@attribute2, @value).to_sql
-
-              adapter_is :mysql do
-                sql.should be_like(%Q{`users`.`name` <=> '1-asdf'})
-              end
-
-              adapter_is :sqlite3 do
-                sql.should be_like(%Q{"users"."name" <=> '1-asdf'})
-              end
-
-              adapter_is :postgresql do
-                sql.should be_like(%Q{"users"."name" <=> E'1-asdf'})
-              end
-
-              adapter_is :oracle do
-                sql.should be_like(%Q{"USERS"."NAME" <=> '1-asdf'})
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end