arel-compat 0.4.0

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

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

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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Arel
+  describe Sql::Engine do
+    before do
+      @users = Table.new(:users)
+      @users.delete
+    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

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