arel-compat 0.4.0

data/spec/engines/memory/unit/relations/array_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Arel
+  describe Array do
+    before do
+      @relation = Array.new([
+        [1, 'duck' ],
+        [2, 'duck' ],
+        [3, 'goose']
+      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
+    end
+
+    describe '#attributes' do
+      it 'manufactures attributes corresponding to the names given on construction' do
+        @relation.attributes.should == [
+          Attribute.new(@relation, :id),
+          Attribute.new(@relation, :name)
+        ]
+      end
+    end
+
+    describe '#call' do
+      it "manufactures an array of hashes of attributes to values" do
+        @relation.call.should == [
+          Row.new(@relation, [1, 'duck']),
+          Row.new(@relation, [2, 'duck']),
+          Row.new(@relation, [3, 'goose'])
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Arel
+  describe Insert do
+    before do
+      @relation = Array.new([
+        [1, 'duck' ],
+        [2, 'duck' ],
+        [3, 'goose']
+      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
+    end
+
+    describe '#call' do
+      it "manufactures an array of hashes of attributes to values" do
+        @relation                                                         \
+          .insert(@relation[:id] => 4, @relation[:name] => 'guinea fowl') \
+         do |relation|
+           relation.should == [
+             Row.new(relation, [1, 'duck']),
+             Row.new(relation, [2, 'duck']),
+             Row.new(relation, [3, 'goose']),
+             Row.new(relation, [4, 'guinea fowl'])
+           ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module Arel
+  describe Join do
+    before do
+      @relation1 = Array.new([
+        [1, 'duck' ],
+        [2, 'duck' ],
+        [3, 'goose']
+      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
+      @relation2 = @relation1.alias
+    end
+
+    describe InnerJoin do
+      describe '#call' do
+        it 'combines the two tables where the predicate obtains' do
+          @relation1                                    \
+            .join(@relation2)                           \
+              .on(@relation1[:id].eq(@relation2[:id]))  \
+          .let do |relation|
+            relation.call.should == [
+              Row.new(relation, [1, 'duck',  1, 'duck' ]),
+              Row.new(relation, [2, 'duck',  2, 'duck' ]),
+              Row.new(relation, [3, 'goose', 3, 'goose'])
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/engines/memory/unit/relations/order_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module Arel
+  describe Order do
+    before do
+      @relation = Array.new([
+        [1, 'duck' ],
+        [2, 'duck' ],
+        [3, 'goose']
+      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
+    end
+
+    describe '#call' do
+      it 'sorts the relation with the provided ordering' do
+        @relation                     \
+          .order(@relation[:id].desc) \
+        .let do |relation|
+          relation.call.should == [
+            Row.new(relation, [3, 'goose']),
+            Row.new(relation, [2, 'duck' ]),
+            Row.new(relation, [1, 'duck' ])
+          ]
+        end
+      end
+    end
+  end
+end

data/spec/engines/memory/unit/relations/project_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module Arel
+  describe Project do
+    before do
+      @relation = Array.new([
+        [1, 'duck' ],
+        [2, 'duck' ],
+        [3, 'goose']
+      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
+    end
+
+    describe '#call' do
+      it 'retains only the attributes that are provided' do
+        @relation                   \
+          .project(@relation[:id])  \
+        .let do |relation|
+          relation.call.should == [
+            Row.new(relation, [1]),
+            Row.new(relation, [2]),
+            Row.new(relation, [3])
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Arel
+  describe Skip do
+    before do
+      @relation = Array.new([
+        [1, 'duck' ],
+        [2, 'duck' ],
+        [3, 'goose']
+      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
+    end
+
+    describe '#call' do
+      it 'removes the first n rows' do
+        @relation   \
+          .skip(1)  \
+        .let do |relation|
+          relation.call.should == [
+            Row.new(relation, [2, 'duck']),
+            Row.new(relation, [3, 'goose']),
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Arel
+  describe Take do
+    before do
+      @relation = Array.new([
+        [1, 'duck' ],
+        [2, 'duck' ],
+        [3, 'goose']
+      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
+    end
+
+    describe '#call' do
+      it 'removes the rows after the first n' do
+        @relation   \
+          .take(2)  \
+        .let do |relation|
+          relation.call.should == [
+            Row.new(relation, [1, 'duck']),
+            Row.new(relation, [2, 'duck']),
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Arel
+  describe Where do
+    before do
+      @relation = Array.new([
+        [1, 'duck' ],
+        [2, 'duck' ],
+        [3, 'goose']
+      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
+    end
+
+    describe '#call' do
+      it 'filters the relation with the provided predicate' do
+        @relation                       \
+          .where(@relation[:id].lt(3))  \
+        .let do |relation|
+          relation.call.should == [
+            Row.new(relation, [1, 'duck']),
+            Row.new(relation, [2, 'duck']),
+          ]
+        end
+      end
+
+      describe 'when filtering a where relation' do
+        it 'further filters the already-filtered relation with the provided predicate' do
+          @relation                       \
+            .where(@relation[:id].gt(1))  \
+            .where(@relation[:id].lt(3))  \
+          .let do |relation|
+            relation.call.should == [
+              Row.new(relation, [2, 'duck'])
+            ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,258 @@
+require 'spec_helper'
+
+module Arel
+  describe Join do
+    before do
+      @relation1 = Table(:users)
+      @relation2 = @relation1.alias
+      @predicate = @relation1[:id].eq(@relation2[:id])
+    end
+
+    describe 'when joining a relation to itself' do
+      describe '#to_sql' do
+        it 'manufactures sql aliasing the table and attributes properly in the join predicate and the where clause' do
+          sql = @relation1.join(@relation2).on(@predicate).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT `users`.`id`, `users`.`name`, `users_2`.`id`, `users_2`.`name`
+              FROM `users`
+                INNER JOIN `users` `users_2`
+                  ON `users`.`id` = `users_2`.`id`
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT "USERS"."ID", "USERS"."NAME", "USERS_2"."ID", "USERS_2"."NAME"
+              FROM "USERS"
+                INNER JOIN "USERS" "USERS_2"
+                  ON "USERS"."ID" = "USERS_2"."ID"
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT "users"."id", "users"."name", "users_2"."id", "users_2"."name"
+              FROM "users"
+                INNER JOIN "users" "users_2"
+                  ON "users"."id" = "users_2"."id"
+            })
+          end
+        end
+
+        describe 'when joining with a where on the same relation' do
+          it 'manufactures sql aliasing the tables properly' do
+            sql = @relation1                                 \
+              .join(@relation2.where(@relation2[:id].eq(1))) \
+                .on(@predicate)                              \
+            .to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{
+                SELECT `users`.`id`, `users`.`name`, `users_2`.`id`, `users_2`.`name`
+                FROM `users`
+                  INNER JOIN `users` `users_2`
+                    ON `users`.`id` = `users_2`.`id` AND `users_2`.`id` = 1
+              })
+            end
+
+            adapter_is :oracle do
+              sql.should be_like(%Q{
+                SELECT "USERS"."ID", "USERS"."NAME", "USERS_2"."ID", "USERS_2"."NAME"
+                FROM "USERS"
+                  INNER JOIN "USERS" "USERS_2"
+                    ON "USERS"."ID" = "USERS_2"."ID" AND "USERS_2"."ID" = 1
+              })
+            end
+
+            adapter_is_not :mysql, :oracle do
+              sql.should be_like(%Q{
+                SELECT "users"."id", "users"."name", "users_2"."id", "users_2"."name"
+                FROM "users"
+                  INNER JOIN "users" "users_2"
+                    ON "users"."id" = "users_2"."id" AND "users_2"."id" = 1
+              })
+            end
+          end
+
+          describe 'when the where occurs before the alias' do
+            it 'manufactures sql aliasing the predicates properly' do
+              relation2 = @relation1.where(@relation1[:id].eq(1)).alias
+
+              sql = @relation1                            \
+                .join(relation2)                          \
+                  .on(relation2[:id].eq(@relation1[:id])) \
+              .to_sql
+
+              adapter_is :mysql do
+                sql.should be_like(%Q{
+                  SELECT `users`.`id`, `users`.`name`, `users_2`.`id`, `users_2`.`name`
+                  FROM `users`
+                  INNER JOIN `users` `users_2`
+                    ON `users_2`.`id` = `users`.`id` AND `users_2`.`id` = 1
+                })
+              end
+
+              adapter_is :oracle do
+                sql.should be_like(%Q{
+                  SELECT "USERS"."ID", "USERS"."NAME", "USERS_2"."ID", "USERS_2"."NAME"
+                  FROM "USERS"
+                  INNER JOIN "USERS" "USERS_2"
+                    ON "USERS_2"."ID" = "USERS"."ID" AND "USERS_2"."ID" = 1
+                })
+              end
+
+              adapter_is_not :mysql, :oracle do
+                sql.should be_like(%Q{
+                  SELECT "users"."id", "users"."name", "users_2"."id", "users_2"."name"
+                  FROM "users"
+                  INNER JOIN "users" "users_2"
+                    ON "users_2"."id" = "users"."id" AND "users_2"."id" = 1
+                })
+              end
+            end
+          end
+        end
+
+        describe 'when joining the relation to itself multiple times' do
+          before do
+            @relation3 = @relation1.alias
+          end
+
+          describe 'when joining left-associatively' do
+            it 'manufactures sql aliasing the tables properly' do
+              sql = @relation1                                \
+                .join(@relation2                              \
+                  .join(@relation3)                           \
+                    .on(@relation2[:id].eq(@relation3[:id]))) \
+                  .on(@relation1[:id].eq(@relation2[:id]))                                 \
+              .to_sql
+
+              adapter_is :mysql do
+                sql.should be_like(%Q{
+                  SELECT `users`.`id`, `users`.`name`, `users_2`.`id`, `users_2`.`name`, `users_3`.`id`, `users_3`.`name`
+                  FROM `users`
+                    INNER JOIN `users` `users_2`
+                      ON `users`.`id` = `users_2`.`id`
+                    INNER JOIN `users` `users_3`
+                      ON `users_2`.`id` = `users_3`.`id`
+                })
+              end
+
+              adapter_is :oracle do
+                sql.should be_like(%Q{
+                  SELECT "USERS"."ID", "USERS"."NAME", "USERS_2"."ID", "USERS_2"."NAME", "USERS_3"."ID", "USERS_3"."NAME"
+                  FROM "USERS"
+                    INNER JOIN "USERS" "USERS_2"
+                      ON "USERS"."ID" = "USERS_2"."ID"
+                    INNER JOIN "USERS" "USERS_3"
+                      ON "USERS_2"."ID" = "USERS_3"."ID"
+                })
+              end
+
+              adapter_is_not :mysql, :oracle do
+                sql.should be_like(%Q{
+                  SELECT "users"."id", "users"."name", "users_2"."id", "users_2"."name", "users_3"."id", "users_3"."name"
+                  FROM "users"
+                    INNER JOIN "users" "users_2"
+                      ON "users"."id" = "users_2"."id"
+                    INNER JOIN "users" "users_3"
+                      ON "users_2"."id" = "users_3"."id"
+                })
+              end
+            end
+          end
+
+          describe 'when joining right-associatively' do
+            it 'manufactures sql aliasing the tables properly' do
+              sql = @relation1                                              \
+                .join(@relation2).on(@relation1[:id].eq(@relation2[:id]))   \
+                .join(@relation3).on(@relation2[:id].eq(@relation3[:id]))   \
+              .to_sql
+
+              adapter_is :mysql do
+                sql.should be_like(%Q{
+                  SELECT `users`.`id`, `users`.`name`, `users_2`.`id`, `users_2`.`name`, `users_3`.`id`, `users_3`.`name`
+                  FROM `users`
+                    INNER JOIN `users` `users_2`
+                      ON `users`.`id` = `users_2`.`id`
+                    INNER JOIN `users` `users_3`
+                      ON `users_2`.`id` = `users_3`.`id`
+                })
+              end
+
+              adapter_is :oracle do
+                sql.should be_like(%Q{
+                  SELECT "USERS"."ID", "USERS"."NAME", "USERS_2"."ID", "USERS_2"."NAME", "USERS_3"."ID", "USERS_3"."NAME"
+                  FROM "USERS"
+                    INNER JOIN "USERS" "USERS_2"
+                      ON "USERS"."ID" = "USERS_2"."ID"
+                    INNER JOIN "USERS" "USERS_3"
+                      ON "USERS_2"."ID" = "USERS_3"."ID"
+                })
+              end
+
+              adapter_is_not :mysql, :oracle do
+                sql.should be_like(%Q{
+                  SELECT "users"."id", "users"."name", "users_2"."id", "users_2"."name", "users_3"."id", "users_3"."name"
+                  FROM "users"
+                    INNER JOIN "users" "users_2"
+                      ON "users"."id" = "users_2"."id"
+                    INNER JOIN "users" "users_3"
+                      ON "users_2"."id" = "users_3"."id"
+                })
+              end
+            end
+          end
+        end
+      end
+
+      describe '[]' do
+        describe 'when given an attribute belonging to both sub-relations' do
+          it 'disambiguates the relation that serves as the ancestor to the attribute' do
+            @relation1          \
+              .join(@relation2) \
+                .on(@predicate) \
+            .should disambiguate_attributes(@relation1[:id], @relation2[:id])
+          end
+
+          describe 'when both relations are compound and only one is an alias' do
+            it 'disambiguates the relation that serves as the ancestor to the attribute' do
+              compound1 = @relation1.where(@predicate)
+              compound2 = compound1.alias
+              compound1           \
+                .join(compound2)  \
+                  .on(@predicate) \
+              .should disambiguate_attributes(compound1[:id], compound2[:id])
+            end
+          end
+
+          describe 'when the left relation is extremely compound' do
+            it 'disambiguates the relation that serves as the ancestor to the attribute' do
+              @relation1            \
+                .where(@predicate)  \
+                .where(@predicate)  \
+                .join(@relation2)   \
+                  .on(@predicate)   \
+              .should disambiguate_attributes(@relation1[:id], @relation2[:id])
+            end
+          end
+
+          describe 'when the right relation is extremely compound' do
+            it 'disambiguates the relation that serves as the ancestor to the attribute' do
+              @relation1                  \
+                .join(                    \
+                  @relation2              \
+                    .where(@predicate)    \
+                    .where(@predicate)    \
+                    .where(@predicate))   \
+                  .on(@predicate)         \
+              .should disambiguate_attributes(@relation1[:id], @relation2[:id])
+            end
+          end
+        end
+      end
+    end
+  end
+end