dm-core 0.10.1 → 0.10.2

data/spec/semipublic/query_spec.rb

@@ -21,7 +21,7 @@ describe DataMapper::Query do
       property :password, Password
       property :balance,  BigDecimal
 
-      belongs_to :referrer, self, :nullable => true
+      belongs_to :referrer, self, :required => false
       has n, :referrals, self, :inverse => :referrer
     end
 
@@ -175,14 +175,6 @@ describe DataMapper::Query do
         end
       end
 
-      describe 'that is an empty Array and the unique option is false' do
-        it 'should raise an exception' do
-          lambda {
-            DataMapper::Query.new(@repository, @model, @options.update(:fields => [], :unique => false))
-          }.should raise_error(ArgumentError, '+options[:fields]+ should not be empty if +options[:unique]+ is false')
-        end
-      end
-
       describe 'that is an Array containing an unknown Symbol' do
         it 'should raise an exception' do
           lambda {
@@ -579,24 +571,26 @@ describe DataMapper::Query do
           end
         end
 
-        describe 'with a Proc value' do
+        describe 'with an Array with 1 entry' do
           before :all do
-            @options[:conditions] = { :name => lambda { 'Dan Kubb' } }
+            @options[:conditions] = { :name => [ 'Dan Kubb' ] }
             @return = DataMapper::Query.new(@repository, @model, @options.freeze)
           end
 
           it { @return.should be_kind_of(DataMapper::Query) }
 
           it 'should set the conditions' do
-            @return.conditions.should ==
-              DataMapper::Query::Conditions::Operation.new(
-                :and,
-                DataMapper::Query::Conditions::Comparison.new(
-                  :eql,
-                  @model.properties[:name],
-                  'Dan Kubb'
+            pending do
+              @return.conditions.should ==
+                DataMapper::Query::Conditions::Operation.new(
+                  :and,
+                  DataMapper::Query::Conditions::Comparison.new(
+                    :eql,
+                    @model.properties[:name],
+                    'Dan Kubb'
+                  )
                 )
-              )
+            end
           end
 
           it 'should be valid' do
@@ -604,9 +598,9 @@ describe DataMapper::Query do
           end
         end
 
-        describe 'with an Array with 1 entry' do
+        describe 'with an Array with no entries' do
           before :all do
-            @options[:conditions] = { :name => [ 'Dan Kubb' ] }
+            @options[:conditions] = { :name => [] }
             @return = DataMapper::Query.new(@repository, @model, @options.freeze)
           end
 
@@ -626,8 +620,8 @@ describe DataMapper::Query do
             end
           end
 
-          it 'should be valid' do
-            @return.should be_valid
+          it 'should not be valid' do
+            @return.should_not be_valid
           end
         end
 
@@ -814,14 +808,6 @@ describe DataMapper::Query do
         end
       end
 
-      describe 'that is a Hash with a not operator that has an empty Array' do
-        it 'should raise an exception' do
-          lambda {
-            DataMapper::Query.new(@repository, @model, @options.update(:conditions => { :name.not => [] }))
-          }.should raise_error(ArgumentError, 'Cannot use \'not\' operator with a bind value that is an empty Array for #<DataMapper::Query::Operator @target=:name @operator=:not>')
-        end
-      end
-
       describe 'that is a Hash with a key of a type that is not permitted' do
         it 'should raise an exception' do
           lambda {
@@ -924,6 +910,44 @@ describe DataMapper::Query do
     end
 
     describe 'with an order option' do
+      describe 'that is a single Symbol' do
+        before :all do
+          @options[:order] = :name
+          @return = DataMapper::Query.new(@repository, @model, @options.freeze)
+        end
+
+        it { @return.should be_kind_of(DataMapper::Query) }
+
+        it 'should set the order' do
+          @return.order.should == [ DataMapper::Query::Direction.new(@model.properties[:name]) ]
+        end
+      end
+
+      describe 'that is a single String' do
+        before :all do
+          @options[:order] = 'name'
+          @return = DataMapper::Query.new(@repository, @model, @options.freeze)
+        end
+
+        it { @return.should be_kind_of(DataMapper::Query) }
+
+        it 'should set the order' do
+          @return.order.should == [ DataMapper::Query::Direction.new(@model.properties[:name]) ]
+        end
+      end
+
+      describe 'that is a single Property' do
+        before :all do
+          @options[:order] = @model.properties.values_at(:name)
+          @return = DataMapper::Query.new(@repository, @model, @options.freeze)
+        end
+
+        it { @return.should be_kind_of(DataMapper::Query) }
+
+        it 'should set the order' do
+          @return.order.should == [ DataMapper::Query::Direction.new(@model.properties[:name]) ]
+        end
+      end
       describe 'that is an Array containing a Symbol' do
         before :all do
           @return = DataMapper::Query.new(@repository, @model, @options.freeze)
@@ -1039,8 +1063,8 @@ describe DataMapper::Query do
       describe 'that is invalid' do
         it 'should raise an exception' do
           lambda {
-            DataMapper::Query.new(@repository, @model, @options.update(:order => :name))
-          }.should raise_error(ArgumentError, '+options[:order]+ should be Array, but was Symbol')
+            DataMapper::Query.new(@repository, @model, @options.update(:order => 'unknown'))
+          }.should raise_error(ArgumentError, "+options[:order]+ entry \"unknown\" does not map to a property in #{@model}")
         end
       end
 
@@ -1141,7 +1165,7 @@ describe DataMapper::Query do
 
       describe 'that is missing' do
         before :all do
-          @return = DataMapper::Query.new(@repository, @model, @options.except(:unique).freeze)
+          @return = DataMapper::Query.new(@repository, @model, @options.except(:unique, :links).freeze)
         end
 
         it { @return.should be_kind_of(DataMapper::Query) }
@@ -1281,16 +1305,24 @@ describe DataMapper::Query do
     class ::User
       include DataMapper::Resource
 
-      property :name, String, :key => true
+      property :name,        String, :key => true
       property :citizenship, String
 
-      belongs_to :referrer, self, :nullable => true
-      has n, :referrals, self, :inverse => :referrer
+      belongs_to :referrer, self, :required => false
+      has n, :referrals,    self, :inverse => :referrer
+      has n, :grandparents, self, :through => :referrals, :via => :referrer
+    end
+
+    class ::Other
+      include DataMapper::Resource
 
-      # TODO: figure out a way to remove this
-      assert_valid
+      property :id, Serial
     end
 
+    # TODO: figure out how to remove these
+    User.send(:assert_valid)
+    Other.send(:assert_valid)
+
     @repository = DataMapper::Repository.new(:default)
     @model      = User
     @options    = { :limit => 3 }
@@ -1312,7 +1344,9 @@ describe DataMapper::Query do
     }
   end
 
-  it { @query.should respond_to(:==) }
+  subject { @query }
+
+  it { should respond_to(:==) }
 
   describe '#==' do
     describe 'when other is equal' do
@@ -1394,7 +1428,7 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:conditions) }
+  it { should respond_to(:conditions) }
 
   describe '#conditions' do
     before :all do
@@ -1418,13 +1452,388 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:dup) }
+  [ :difference, :- ].each do |method|
+    it { should respond_to(method) }
+
+    describe "##{method}" do
+      supported_by :all do
+        before :all do
+          @key = @model.key(@repository.name)
+
+          @self_relationship = DataMapper::Associations::OneToMany::Relationship.new(
+            :self,
+            @model,
+            @model,
+            {
+              :child_key              => @key.map { |p| p.name },
+              :parent_key             => @key.map { |p| p.name },
+              :child_repository_name  => @repository,
+              :parent_repository_name => @repository,
+            }
+          )
+
+          10.times do |n|
+            @model.create(:name => "#{@model} #{n}")
+          end
+        end
+
+        subject { @query.send(method, @other) }
+
+        describe 'with other matching everything' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model)
+
+            @expected = DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb')
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should factor out the operation matching everything' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with self matching everything' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:not,
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb')
+            )
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should factor out the operation matching everything, and negate the other' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with self having a limit' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :limit => 5)
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:in, @self_relationship, @model.all(@query.merge(:fields => @key))),
+              DataMapper::Query::Conditions::Operation.new(:not,
+                DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb')
+              )
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together, and negate the other' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with other having a limit' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, :limit => 5)
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb'),
+              DataMapper::Query::Conditions::Operation.new(:not,
+                DataMapper::Query::Conditions::Comparison.new(:in, @self_relationship, @model.all(@other.merge(:fields => @key)))
+              )
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together, and negate the other' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with self having an offset > 0' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :offset => 5, :limit => 5)
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:in, @self_relationship, @model.all(@query.merge(:fields => @key))),
+              DataMapper::Query::Conditions::Operation.new(:not,
+                DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb')
+              )
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together, and negate the other' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with other having an offset > 0' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, :offset => 5, :limit => 5)
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb'),
+              DataMapper::Query::Conditions::Operation.new(:not,
+                DataMapper::Query::Conditions::Comparison.new(:in, @self_relationship, @model.all(@other.merge(:fields => @key)))
+              )
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together, and negate the other' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with self having links' do
+          before :all do
+            @do_adapter = defined?(DataMapper::Adapters::DataObjectsAdapter) && @adapter.kind_of?(DataMapper::Adapters::DataObjectsAdapter)
+          end
+
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :links => [ :referrer ])
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:in, @self_relationship, @model.all(@query.merge(:fields => @key))),
+              DataMapper::Query::Conditions::Operation.new(:not,
+                DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb')
+              )
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together, and negate the other query' do
+            pending_if 'TODO: Fix once table aliasing works', @do_adapter do
+              subject.conditions.should == @expected
+            end
+          end
+        end
+
+        describe 'with other having links' do
+          before :all do
+            @do_adapter = defined?(DataMapper::Adapters::DataObjectsAdapter) && @adapter.kind_of?(DataMapper::Adapters::DataObjectsAdapter)
+          end
+
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, :links => [ :referrer ])
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb'),
+              DataMapper::Query::Conditions::Operation.new(:not,
+                DataMapper::Query::Conditions::Comparison.new(:in, @self_relationship, @model.all(@other.merge(:fields => @key)))
+              )
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together, and negate the other query' do
+            pending_if 'TODO: Fix once table aliasing works', @do_adapter do
+              subject.conditions.should == @expected
+            end
+          end
+        end
+
+        describe 'with different conditions, no links/offset/limit' do
+          before do
+            property = @model.properties[:name]
+
+            @query = DataMapper::Query.new(@repository, @model, property.name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, property.name => 'John Doe')
+
+            @query.conditions.should_not == @other.conditions
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:eql, property, 'Dan Kubb'),
+              DataMapper::Query::Conditions::Operation.new(:not,
+                DataMapper::Query::Conditions::Comparison.new(:eql, property, 'John Doe')
+              )
+            )
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should AND the conditions together, and negate the other query' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with different fields' do
+          before do
+            @property = @model.properties[:name]
+
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :fields => [ @property ])
+
+            @query.fields.should_not == @other.fields
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should == DataMapper::Query::Conditions::Operation.new(:and) }
+
+          it 'should use the other fields' do
+            subject.fields.should == [ @property ]
+          end
+        end
+
+        describe 'with different order' do
+          before do
+            @property = @model.properties[:name]
+
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :order => [ DataMapper::Query::Direction.new(@property, :desc) ])
+
+            @query.order.should_not == @other.order
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should == DataMapper::Query::Conditions::Operation.new(:and) }
+
+          it 'should use the other order' do
+            subject.order.should == [ DataMapper::Query::Direction.new(@property, :desc) ]
+          end
+        end
+
+        describe 'with different unique' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :unique => true)
+
+            @query.unique?.should_not == @other.unique?
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should == DataMapper::Query::Conditions::Operation.new(:and) }
+
+          it 'should use the other unique' do
+            subject.unique?.should == true
+          end
+        end
+
+        describe 'with different add_reversed' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :add_reversed => true)
+
+            @query.add_reversed?.should_not == @other.add_reversed?
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should == DataMapper::Query::Conditions::Operation.new(:and) }
+
+          it 'should use the other add_reversed' do
+            subject.add_reversed?.should == true
+          end
+        end
+
+        describe 'with different reload' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :reload => true)
+
+            @query.reload?.should_not == @other.reload?
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should == DataMapper::Query::Conditions::Operation.new(:and) }
+
+          it 'should use the other reload' do
+            subject.reload?.should == true
+          end
+        end
+
+        describe 'with different models' do
+          before { @other = DataMapper::Query.new(@repository, Other) }
+
+          it { method(:subject).should raise_error(ArgumentError) }
+        end
+      end
+    end
+  end
+
+  it { should respond_to(:dup) }
 
   describe '#dup' do
-    it 'should be awesome'
+    before :all do
+      @new = @query.dup
+    end
+
+    it 'should return a Query' do
+      @new.should be_kind_of(DataMapper::Query)
+    end
+
+    it 'should not equal query' do
+      @new.should_not equal(@query)
+    end
+
+    it 'should eql query' do
+      @new.should eql(@query)
+    end
+
+    it 'should == query' do
+      @new.should == @query
+    end
   end
 
-  it { @query.should respond_to(:eql?) }
+  it { should respond_to(:eql?) }
 
   describe '#eql?' do
     describe 'when other is equal' do
@@ -1476,7 +1885,7 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:fields) }
+  it { should respond_to(:fields) }
 
   describe '#fields' do
     before :all do
@@ -1490,10 +1899,10 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:filter_records) }
+  it { should respond_to(:filter_records) }
 
-  supported_by :all do
-    describe '#filter_records' do
+  describe '#filter_records' do
+    supported_by :all do
       before :all do
         @john = { 'name' => 'John Doe',  'referrer_name' => nil         }
         @sam  = { 'name' => 'Sam Smoot', 'referrer_name' => nil         }
@@ -1520,7 +1929,7 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:inspect) }
+  it { should respond_to(:inspect) }
 
   describe '#inspect' do
     before :all do
@@ -1544,12 +1953,363 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:limit) }
-
-  describe '#limit' do
-    before :all do
-      @return = @query.limit
-    end
+  [ :intersection, :& ].each do |method|
+    it { should respond_to(method) }
+
+    describe "##{method}" do
+      supported_by :all do
+        before :all do
+          @key = @model.key(@repository.name)
+
+          @self_relationship = DataMapper::Associations::OneToMany::Relationship.new(
+            :self,
+            @model,
+            @model,
+            {
+              :child_key              => @key.map { |p| p.name },
+              :parent_key             => @key.map { |p| p.name },
+              :child_repository_name  => @repository,
+              :parent_repository_name => @repository,
+            }
+          )
+
+          10.times do |n|
+            @model.create(:name => "#{@model} #{n}")
+          end
+        end
+
+        subject { @query.send(method, @other) }
+
+        describe 'with equivalent query' do
+          before { @other = @query.dup }
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { should == @query }
+        end
+
+        describe 'with other matching everything' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model)
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should factor out the operation matching everything' do
+            pending 'TODO: compress Query#conditions for proper comparison' do
+              should == DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            end
+          end
+        end
+
+        describe 'with self matching everything' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should factor out the operation matching everything' do
+            pending 'TODO: compress Query#conditions for proper comparison' do
+              should == DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            end
+          end
+        end
+
+        describe 'with self having a limit' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :limit => 5)
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,       @model.all(@query.merge(:fields => @key))),
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb')
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with other having a limit' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, :limit => 5)
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb'),
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,       @model.all(@other.merge(:fields => @key)))
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with self having an offset > 0' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :offset => 5, :limit => 5)
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,       @model.all(@query.merge(:fields => @key))),
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb')
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with other having an offset > 0' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, :offset => 5, :limit => 5)
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb'),
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,        @model.all(@other.merge(:fields => @key)))
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with self having links' do
+          before :all do
+            @do_adapter = defined?(DataMapper::Adapters::DataObjectsAdapter) && @adapter.kind_of?(DataMapper::Adapters::DataObjectsAdapter)
+          end
+
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :links => [ :referrer ])
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,       @model.all(@query.merge(:fields => @key))),
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb')
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together' do
+            pending_if 'TODO: Fix once table aliasing works', @do_adapter do
+              subject.conditions.should == @expected
+            end
+          end
+        end
+
+        describe 'with other having links' do
+          before :all do
+            @do_adapter = defined?(DataMapper::Adapters::DataObjectsAdapter) && @adapter.kind_of?(DataMapper::Adapters::DataObjectsAdapter)
+          end
+
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, :links => [ :referrer ])
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb'),
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,       @model.all(@other.merge(:fields => @key)))
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and AND them together' do
+            pending_if 'TODO: Fix once table aliasing works', @do_adapter do
+              subject.conditions.should == @expected
+            end
+          end
+        end
+
+        describe 'with different conditions, no links/offset/limit' do
+          before do
+            property = @model.properties[:name]
+
+            @query = DataMapper::Query.new(@repository, @model, property.name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, property.name => 'John Doe')
+
+            @query.conditions.should_not == @other.conditions
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:and,
+              DataMapper::Query::Conditions::Comparison.new(:eql, property, 'Dan Kubb'),
+              DataMapper::Query::Conditions::Comparison.new(:eql, property, 'John Doe')
+            )
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should AND the conditions together' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with different fields' do
+          before do
+            @property = @model.properties[:name]
+
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :fields => [ @property ])
+
+            @query.fields.should_not == @other.fields
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should be_nil }
+
+          it 'should use the other fields' do
+            subject.fields.should == [ @property ]
+          end
+        end
+
+        describe 'with different order' do
+          before do
+            @property = @model.properties[:name]
+
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :order => [ DataMapper::Query::Direction.new(@property, :desc) ])
+
+            @query.order.should_not == @other.order
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should be_nil }
+
+          it 'should use the other order' do
+            subject.order.should == [ DataMapper::Query::Direction.new(@property, :desc) ]
+          end
+        end
+
+        describe 'with different unique' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :unique => true)
+
+            @query.unique?.should_not == @other.unique?
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should be_nil }
+
+          it 'should use the other unique' do
+            subject.unique?.should == true
+          end
+        end
+
+        describe 'with different add_reversed' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :add_reversed => true)
+
+            @query.add_reversed?.should_not == @other.add_reversed?
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should be_nil }
+
+          it 'should use the other add_reversed' do
+            subject.add_reversed?.should == true
+          end
+        end
+
+        describe 'with different reload' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :reload => true)
+
+            @query.reload?.should_not == @other.reload?
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should use the other reload' do
+            subject.reload?.should == true
+          end
+        end
+
+        describe 'with different models' do
+          before { @other = DataMapper::Query.new(@repository, Other) }
+
+          it { method(:subject).should raise_error(ArgumentError) }
+        end
+      end
+    end
+  end
+
+  it { should respond_to(:limit) }
+
+  describe '#limit' do
+    before :all do
+      @return = @query.limit
+    end
 
     it { @return.should be_kind_of(Integer) }
 
@@ -1558,10 +2318,10 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:limit_records) }
+  it { should respond_to(:limit_records) }
 
-  supported_by :all do
-    describe '#limit_records' do
+  describe '#limit_records' do
+    supported_by :all do
       before :all do
         @john = { 'name' => 'John Doe',  'referrer_name' => nil         }
         @sam  = { 'name' => 'Sam Smoot', 'referrer_name' => nil         }
@@ -1588,7 +2348,7 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:links) }
+  it { should respond_to(:links) }
 
   describe '#links' do
     before :all do
@@ -1600,10 +2360,10 @@ describe DataMapper::Query do
     it { @return.should be_empty }
   end
 
-  it { @query.should respond_to(:match_records) }
+  it { should respond_to(:match_records) }
 
-  supported_by :all do
-    describe '#match_records' do
+  describe '#match_records' do
+    supported_by :all do
       before :all do
         @john = { 'name' => 'John Doe',  'referrer_name' => nil         }
         @sam  = { 'name' => 'Sam Smoot', 'referrer_name' => nil         }
@@ -1630,32 +2390,32 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:merge) }
+  it { should respond_to(:merge) }
 
   describe '#merge' do
-    describe "with a Hash" do
-      before(:each) do
+    describe 'with a Hash' do
+      before do
         @return = @query.merge({ :limit => 202 })
       end
 
-      it "does not affect the receiver" do
+      it 'does not affect the receiver' do
         @query.options[:limit].should == 3
       end
     end
 
-    describe "with a Query" do
-      before(:each) do
+    describe 'with a Query' do
+      before do
         @other  = DataMapper::Query.new(@repository, @model, @options.update(@other_options))
         @return = @query.merge(@other)
       end
 
-      it "does not affect the receiver" do
+      it 'does not affect the receiver' do
         @query.options[:limit].should == 3
       end
     end
   end
 
-  it { @query.should respond_to(:model) }
+  it { should respond_to(:model) }
 
   describe '#model' do
     before :all do
@@ -1669,7 +2429,7 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:offset) }
+  it { should respond_to(:offset) }
 
   describe '#offset' do
     before :all do
@@ -1683,7 +2443,7 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:order) }
+  it { should respond_to(:order) }
 
   describe '#order' do
     before :all do
@@ -1697,7 +2457,7 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:raw?) }
+  it { should respond_to(:raw?) }
 
   describe '#raw?' do
     describe 'when the query contains raw conditions' do
@@ -1705,15 +2465,15 @@ describe DataMapper::Query do
         @query.update(:conditions => [ 'name = ?', 'Dan Kubb' ])
       end
 
-      it { @query.should be_raw }
+      it { should be_raw }
     end
 
     describe 'when the query does not contain raw conditions' do
-      it { @query.should_not be_raw }
+      it { should_not be_raw }
     end
   end
 
-  it { @query.should respond_to(:relative) }
+  it { should respond_to(:relative) }
 
   describe '#relative' do
     describe 'with a Hash' do
@@ -1733,45 +2493,6 @@ describe DataMapper::Query do
         end
       end
 
-      describe 'using a different repository as a Repository' do
-        before :all do
-          @repository = DataMapper::Repository.new(:other)
-          @return = @query.relative(:repository => @repository)
-        end
-
-        it { @return.should be_kind_of(DataMapper::Query) }
-
-        it 'should not return self' do
-          @return.should_not equal(@original)
-        end
-
-        it 'should set the repository' do
-          @return.repository.should equal(@repository)
-        end
-      end
-
-      describe 'using a different repository as a Symbol' do
-        before :all do
-          @other_adapter = DataMapper.setup(:other, :adapter => :in_memory)
-
-          @return = @query.relative(:repository => :other)
-        end
-
-        after :all do
-          DataMapper::Repository.adapters.delete(@other_adapter.name)
-        end
-
-        it { @return.should be_kind_of(DataMapper::Query) }
-
-        it 'should not return self' do
-          @return.should_not equal(@original)
-        end
-
-        it 'should set the repository' do
-          @return.repository.should == DataMapper::Repository.new(:other)
-        end
-      end
-
       describe 'using different options' do
         before :all do
           @return = @query.relative(@other_options)
@@ -1884,7 +2605,7 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:reload?) }
+  it { should respond_to(:reload?) }
 
   describe '#reload?' do
     describe 'when the query should reload' do
@@ -1892,15 +2613,15 @@ describe DataMapper::Query do
         @query.update(:reload => true)
       end
 
-      it { @query.should be_reload }
+      it { should be_reload }
     end
 
     describe 'when the query should not reload' do
-      it { @query.should_not be_reload }
+      it { should_not be_reload }
     end
   end
 
-  it { @query.should respond_to(:repository) }
+  it { should respond_to(:repository) }
 
   describe '#repository' do
     before :all do
@@ -1914,7 +2635,7 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:reverse) }
+  it { should respond_to(:reverse) }
 
   describe '#reverse' do
     before :all do
@@ -1943,7 +2664,7 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:reverse!) }
+  it { should respond_to(:reverse!) }
 
   describe '#reverse!' do
     before :all do
@@ -1960,7 +2681,7 @@ describe DataMapper::Query do
   end
 
   [ :slice, :[] ].each do |method|
-    it { @query.should respond_to(method) }
+    it { should respond_to(method) }
 
     describe "##{method}" do
       describe 'with a positive offset' do
@@ -2151,7 +2872,7 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:slice!) }
+  it { should respond_to(:slice!) }
 
   describe '#slice!' do
     describe 'with a positive offset' do
@@ -2341,10 +3062,10 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:sort_records) }
+  it { should respond_to(:sort_records) }
 
-  supported_by :all do
-    describe '#sort_records' do
+  describe '#sort_records' do
+    supported_by :all do
       before :all do
         @john = { 'name' => 'John Doe',  'referrer_name' => nil         }
         @sam  = { 'name' => 'Sam Smoot', 'referrer_name' => nil         }
@@ -2371,7 +3092,356 @@ describe DataMapper::Query do
     end
   end
 
-  it { @query.should respond_to(:unique?) }
+  [ :union, :|, :+ ].each do |method|
+    it { should respond_to(method) }
+
+    describe "##{method}" do
+      supported_by :all do
+        before :all do
+          @key = @model.key(@repository.name)
+
+          @self_relationship = DataMapper::Associations::OneToMany::Relationship.new(
+            :self,
+            @model,
+            @model,
+            {
+              :child_key              => @key.map { |p| p.name },
+              :parent_key             => @key.map { |p| p.name },
+              :child_repository_name  => @repository,
+              :parent_repository_name => @repository,
+            }
+          )
+
+          10.times do |n|
+            @model.create(:name => "#{@model} #{n}")
+          end
+        end
+
+        subject { @query.send(method, @other) }
+
+        describe 'with equivalent query' do
+          before { @other = @query.dup }
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { should == @query }
+        end
+
+        describe 'with other matching everything' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model)
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should match everything' do
+            should == DataMapper::Query.new(@repository, @model)
+          end
+        end
+
+        describe 'with self matching everything' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should match everything' do
+            should == DataMapper::Query.new(@repository, @model)
+          end
+        end
+
+        describe 'with self having a limit' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :limit => 5)
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:or,
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,       @model.all(@query.merge(:fields => @key))),
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb')
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and OR them together' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with other having a limit' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, :limit => 5)
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:or,
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb'),
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,       @model.all(@other.merge(:fields => @key)))
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and OR them together' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with self having an offset > 0' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :offset => 5, :limit => 5)
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:or,
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,       @model.all(@query.merge(:fields => @key))),
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb')
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and OR them together' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with other having an offset > 0' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, :offset => 5, :limit => 5)
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:or,
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb'),
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,        @model.all(@other.merge(:fields => @key)))
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and OR them together' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with self having links' do
+          before :all do
+            @do_adapter = defined?(DataMapper::Adapters::DataObjectsAdapter) && @adapter.kind_of?(DataMapper::Adapters::DataObjectsAdapter)
+          end
+
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :links => [ :referrer ])
+            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:or,
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,       @model.all(@query.merge(:fields => @key))),
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb')
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and OR them together' do
+            pending_if 'TODO: Fix once table aliasing works', @do_adapter do
+              subject.conditions.should == @expected
+            end
+          end
+        end
+
+        describe 'with other having links' do
+          before :all do
+            @do_adapter = defined?(DataMapper::Adapters::DataObjectsAdapter) && @adapter.kind_of?(DataMapper::Adapters::DataObjectsAdapter)
+          end
+
+          before do
+            @query = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, :links => [ :referrer ])
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:or,
+              DataMapper::Query::Conditions::Comparison.new(:eql, @model.properties[:name], 'Dan Kubb'),
+              DataMapper::Query::Conditions::Comparison.new(:in,  @self_relationship,       @model.all(@other.merge(:fields => @key)))
+            )
+          end
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should put each query into a subquery and OR them together' do
+            pending_if 'TODO: Fix once table aliasing works', @do_adapter do
+              subject.conditions.should == @expected
+            end
+          end
+        end
+
+        describe 'with different conditions, no links/offset/limit' do
+          before do
+            property = @model.properties[:name]
+
+            @query = DataMapper::Query.new(@repository, @model, property.name => 'Dan Kubb')
+            @other = DataMapper::Query.new(@repository, @model, property.name => 'John Doe')
+
+            @query.conditions.should_not == @other.conditions
+
+            @expected = DataMapper::Query::Conditions::Operation.new(:or,
+              DataMapper::Query::Conditions::Comparison.new(:eql, property, 'Dan Kubb'),
+              DataMapper::Query::Conditions::Comparison.new(:eql, property, 'John Doe')
+            )
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it 'should OR the conditions together' do
+            subject.conditions.should == @expected
+          end
+        end
+
+        describe 'with different fields' do
+          before do
+            @property = @model.properties[:name]
+
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :fields => [ @property ])
+
+            @query.fields.should_not == @other.fields
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should be_nil }
+
+          it 'should use the other fields' do
+            subject.fields.should == [ @property ]
+          end
+        end
+
+        describe 'with different order' do
+          before do
+            @property = @model.properties[:name]
+
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :order => [ DataMapper::Query::Direction.new(@property, :desc) ])
+
+            @query.order.should_not == @other.order
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should be_nil }
+
+          it 'should use the other order' do
+            subject.order.should == [ DataMapper::Query::Direction.new(@property, :desc) ]
+          end
+        end
+
+        describe 'with different unique' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :unique => true)
+
+            @query.unique?.should_not == @other.unique?
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should be_nil }
+
+          it 'should use the other unique' do
+            subject.unique?.should == true
+          end
+        end
+
+        describe 'with different add_reversed' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :add_reversed => true)
+
+            @query.add_reversed?.should_not == @other.add_reversed?
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should be_nil }
+
+          it 'should use the other add_reversed' do
+            subject.add_reversed?.should == true
+          end
+        end
+
+        describe 'with different reload' do
+          before do
+            @query = DataMapper::Query.new(@repository, @model)
+            @other = DataMapper::Query.new(@repository, @model, :reload => true)
+
+            @query.reload?.should_not == @other.reload?
+          end
+
+          it { should be_kind_of(DataMapper::Query) }
+
+          it { should_not equal(@query) }
+
+          it { should_not equal(@other) }
+
+          it { subject.conditions.should be_nil }
+
+          it 'should use the other reload' do
+            subject.reload?.should == true
+          end
+        end
+
+        describe 'with different models' do
+          before { @other = DataMapper::Query.new(@repository, Other) }
+
+          it { method(:subject).should raise_error(ArgumentError) }
+        end
+      end
+    end
+  end
+
+  it { should respond_to(:unique?) }
 
   describe '#unique?' do
     describe 'when the query is unique' do
@@ -2379,15 +3449,33 @@ describe DataMapper::Query do
         @query.update(:unique => true)
       end
 
-      it { @query.should be_unique }
+      it { should be_unique }
     end
 
     describe 'when the query is not unique' do
-      it { @query.should_not be_unique }
+      it { should_not be_unique }
+    end
+
+    describe 'when links are provided, but unique is not specified' do
+      before :all do
+        @query.should_not be_unique
+        @query.update(:links => [ :referrer ])
+      end
+
+      it { should be_unique }
+    end
+
+    describe 'when links are provided, but unique is false' do
+      before :all do
+        @query.should_not be_unique
+        @query.update(:links => [ :referrer ], :unique => false)
+      end
+
+      it { should_not be_unique }
     end
   end
 
-  it { @query.should respond_to(:update) }
+  it { should respond_to(:update) }
 
   describe '#update' do
     describe 'with a Query' do
@@ -2406,20 +3494,21 @@ describe DataMapper::Query do
       describe 'that has conditions set' do
         before :all do
           @and_operation = DataMapper::Query::Conditions::Operation.new(:and)
-          @or_operation = DataMapper::Query::Conditions::Operation.new(:or)
+          @or_operation  = DataMapper::Query::Conditions::Operation.new(:or)
 
-          @and_operation << DataMapper::Query::Conditions::Comparison.new(:eql,User.name,"Dan Kubb")
-          @and_operation << DataMapper::Query::Conditions::Comparison.new(:eql,User.citizenship,"Canada")
+          @and_operation << DataMapper::Query::Conditions::Comparison.new(:eql, User.properties[:name],       'Dan Kubb')
+          @and_operation << DataMapper::Query::Conditions::Comparison.new(:eql, User.properties[:citizenship],'Canada')
 
-          @or_operation << DataMapper::Query::Conditions::Comparison.new(:eql,User.name,"Ted Han")
-          @or_operation << DataMapper::Query::Conditions::Comparison.new(:eql,User.citizenship,"USA")
-          @query_one = DataMapper::Query.new(@repository, @model, {:conditions=>@and_operation})
-          @query_two = DataMapper::Query.new(@repository, @model, {:conditions=>@or_operation})
+          @or_operation << DataMapper::Query::Conditions::Comparison.new(:eql, User.properties[:name],        'Ted Han')
+          @or_operation << DataMapper::Query::Conditions::Comparison.new(:eql, User.properties[:citizenship], 'USA')
+
+          @query_one = DataMapper::Query.new(@repository, @model, :conditions => @and_operation)
+          @query_two = DataMapper::Query.new(@repository, @model, :conditions => @or_operation)
 
           @conditions = @query_one.merge(@query_two).conditions
         end
 
-        it { @conditions.should == (@and_operation << @or_operation) }
+        it { @conditions.should == DataMapper::Query::Conditions::Operation.new(:and, @and_operation, @or_operation) }
       end
 
       describe 'that is for an ancestor model' do
@@ -2612,13 +3701,65 @@ describe DataMapper::Query do
 
         it 'should update the conditions' do
           @return.conditions.should == DataMapper::Query::Conditions::Operation.new(
-                                          :and,
-                                          DataMapper::Query::Conditions::Comparison.new(:eql,
-                                                                                 @model.properties[:name],
-                                                                                 @options[:name]
-                                                                                )
+            :and,
+            DataMapper::Query::Conditions::Comparison.new(
+              :eql,
+              @model.properties[:name],
+              @options[:name]
+            )
+          )
+        end
+      end
+
+      describe 'using raw conditions' do
+        before :all do
+          @query.update(:conditions => [ 'name IS NOT NULL' ])
+
+          @return = @query.update(:conditions => [ 'name = ?', 'Dan Kubb' ])
+        end
+
+        it { @return.should be_kind_of(DataMapper::Query) }
+
+        it { @return.should equal(@original) }
+
+        it 'should update the conditions' do
+          @return.conditions.should == DataMapper::Query::Conditions::Operation.new(
+            :and,
+            [ 'name IS NOT NULL' ],
+            [ 'name = ?', [ 'Dan Kubb' ] ]
           )
-          #@return.conditions.should == [ [ :eql, @model.properties[:name], @options[:name] ] ]
+        end
+      end
+
+      describe 'with the String key mapping to a Query::Path' do
+        before :all do
+          @query.links.should be_empty
+
+          @options = { 'grandparents.name' => 'Dan Kubb' }
+
+          @return = @query.update(@options)
+        end
+
+        it { @return.should be_kind_of(DataMapper::Query) }
+
+        it 'should set the conditions' do
+          @return.conditions.should ==
+            DataMapper::Query::Conditions::Operation.new(
+              :and,
+              DataMapper::Query::Conditions::Comparison.new(
+                :eql,
+                @model.grandparents.name,
+                'Dan Kubb'
+              )
+            )
+        end
+
+        it 'should set the links' do
+          @return.links.should == [ @model.relationships[:referrals], @model.relationships[:referrer] ]
+        end
+
+        it 'should be valid' do
+          @return.should be_valid
         end
       end
     end