sequel 5.15.0 → 5.16.0

data/spec/extensions/nested_attributes_spec.rb

@@ -510,6 +510,46 @@ describe "NestedAttributes plugin" do
       ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
   end
   
+  it "should not attempt to validate nested attributes twice for one_to_one associations when creating them" do
+    @Artist.nested_attributes :first_album
+    validated = []
+    @Album.class_eval do
+      define_method(:validate) do
+        super()
+        validated << self
+      end
+    end
+    a = @Artist.new(:name=>'Ar', :first_album_attributes=>{:name=>'Al'})
+    @db.sqls.must_equal []
+    validated.length.must_equal 0
+    a.save
+    validated.length.must_equal 1
+    check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
+      "UPDATE albums SET artist_id = NULL WHERE (artist_id = 1)",
+      "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)")
+  end
+  
+  it "should not clear reciprocal association before saving new one_to_one associated object" do
+    @Artist.one_to_one :first_album, :clone=>:first_album, :reciprocal=>:artist
+    @Artist.nested_attributes :first_album
+    assoc = []
+    @Album.class_eval do
+      define_method(:after_save) do
+        super()
+        assoc << associations[:artist]
+      end
+    end
+    a = @Artist.new(:name=>'Ar', :first_album_attributes=>{:name=>'Al'})
+    @db.sqls.must_equal []
+    assoc.must_be_empty
+    a.save
+    assoc.length.must_equal 1
+    assoc.first.must_be_kind_of(@Artist)
+    check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
+      "UPDATE albums SET artist_id = NULL WHERE (artist_id = 1)",
+      "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)")
+  end
+  
   it "should not save if nested attribute is not valid and should include nested attribute validation errors in the main object's validation errors" do
     @Artist.class_eval do
       def validate

data/spec/extensions/pg_array_associations_spec.rb

@@ -143,10 +143,10 @@ describe Sequel::Model, "pg_array_associations" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :primary_key=>Sequel.*(:id, 3), :primary_key_method=>:id3, :key=>:tag3_ids, :key_column=>Sequel.pg_array(:tag_ids)[1..2]
     @c2.many_to_pg_array :artists, :clone=>:artists, :primary_key=>Sequel.*(:id, 3), :primary_key_method=>:id3, :key=>:tag3_ids, :key_column=>Sequel.pg_array(:tag_ids)[1..2]
 
-    @c1.filter(:tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids[1:2] @> ARRAY[6]::integer[])"
+    @c1.filter(:tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE ((artists.tag_ids)[1:2] @> ARRAY[6]::integer[])"
     @c2.filter(:artists=>@o1).sql.must_equal "SELECT * FROM tags WHERE ((tags.id * 3) IN (3, 6, 9))"
-    @c1.filter(:tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids[1:2] && (SELECT array_agg((tags.id * 3)) FROM tags WHERE (id = 1))), false)"
-    @c2.filter(:artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE (EXISTS (SELECT 1 FROM (SELECT artists.tag_ids[1:2] AS key FROM artists WHERE (id = 1)) AS t1 WHERE ((tags.id * 3) = any(key))))"
+    @c1.filter(:tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE coalesce(((artists.tag_ids)[1:2] && (SELECT array_agg((tags.id * 3)) FROM tags WHERE (id = 1))), false)"
+    @c2.filter(:artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE (EXISTS (SELECT 1 FROM (SELECT (artists.tag_ids)[1:2] AS key FROM artists WHERE (id = 1)) AS t1 WHERE ((tags.id * 3) = any(key))))"
   end
   
   it "should raise an error if associated model does not have a primary key, and :primary_key is not specified" do
@@ -168,7 +168,7 @@ describe Sequel::Model, "pg_array_associations" do
   
   it "should support a :key_column option" do
     @c2.many_to_pg_array :artists, :clone=>:artists, :key_column=>Sequel.pg_array(:tag_ids)[1..2], :key=>:tag2_ids
-    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids[1:2] @> ARRAY[2]::integer[])"
+    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE ((artists.tag_ids)[1:2] @> ARRAY[2]::integer[])"
   end
   
   it "should support a :primary_key option" do
@@ -211,7 +211,7 @@ describe Sequel::Model, "pg_array_associations" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :dataset=>proc{Tag.where(:id=>tag_ids.map{|x| x*2})}
     @c2.many_to_pg_array :artists, :clone=>:artists, :dataset=>proc{Artist.where(Sequel.pg_array(Sequel.pg_array(:tag_ids)[1..2]).contains([id]))}
     @o1.tags_dataset.sql.must_equal "SELECT * FROM tags WHERE (id IN (2, 4, 6))"
-    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE (tag_ids[1:2] @> ARRAY[2])"
+    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE ((tag_ids)[1:2] @> ARRAY[2])"
   end
 
   it "should support a :limit option" do
@@ -274,7 +274,7 @@ describe Sequel::Model, "pg_array_associations" do
 
     a = @c2.eager(:artists).all
     a.must_equal [@o2]
-    @db.sqls.must_equal ["SELECT * FROM tags", "SELECT * FROM artists WHERE (artists.tag_ids[1:2] && ARRAY[6]::integer[])"]
+    @db.sqls.must_equal ["SELECT * FROM tags", "SELECT * FROM artists WHERE ((artists.tag_ids)[1:2] && ARRAY[6]::integer[])"]
     a.first.artists.must_equal [@o1]
     @db.sqls.must_equal []
   end
@@ -461,13 +461,13 @@ describe Sequel::Model, "pg_array_associations" do
 
     a = @c1.eager_graph(:tags).all
     a.must_equal [@o1]
-    @db.sqls.must_equal ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids[1:2] @> ARRAY[(tags.id * 3)])"]
+    @db.sqls.must_equal ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON ((artists.tag_ids)[1:2] @> ARRAY[(tags.id * 3)])"]
     a.first.tags.must_equal [@o2]
     @db.sqls.must_equal []
 
     a = @c2.eager_graph(:artists).all
     a.must_equal [@o2]
-    @db.sqls.must_equal ["SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON (artists.tag_ids[1:2] @> ARRAY[tags.id3])"]
+    @db.sqls.must_equal ["SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON ((artists.tag_ids)[1:2] @> ARRAY[tags.id3])"]
     a.first.artists.must_equal [@o1]
     @db.sqls.must_equal []
   end

data/spec/extensions/pg_array_ops_spec.rb

@@ -17,12 +17,12 @@ describe "Sequel::Postgres::ArrayOp" do
   end
 
   it "#[] should support subscript access" do
-    @db.literal(@a[1]).must_equal "a[1]"
-    @db.literal(@a[1][2]).must_equal "a[1][2]"
+    @db.literal(@a[1]).must_equal "(a)[1]"
+    @db.literal(@a[1][2]).must_equal "(a)[1][2]"
   end
 
   it "#[] with a range should return an ArrayOp" do
-    @db.literal(@a[1..2].any).must_equal "ANY(a[1:2])"
+    @db.literal(@a[1..2].any).must_equal "ANY((a)[1:2])"
   end
 
   it "#any should use the ANY method" do
@@ -52,12 +52,12 @@ describe "Sequel::Postgres::ArrayOp" do
 
   it "#remove should remove the element from the array" do
     @db.literal(@a.remove(1)).must_equal "array_remove(a, 1)"
-    @db.literal(@a.remove(1)[2]).must_equal "array_remove(a, 1)[2]"
+    @db.literal(@a.remove(1)[2]).must_equal "(array_remove(a, 1))[2]"
   end
 
   it "#remove should replace the element in the array with another" do
     @db.literal(@a.replace(1, 2)).must_equal "array_replace(a, 1, 2)"
-    @db.literal(@a.replace(1, 2)[3]).must_equal "array_replace(a, 1, 2)[3]"
+    @db.literal(@a.replace(1, 2)[3]).must_equal "(array_replace(a, 1, 2))[3]"
   end
 
   it "#unshift should use the || operator in prepend mode" do

data/spec/extensions/pg_hstore_ops_spec.rb

@@ -43,7 +43,7 @@ describe "Sequel::Postgres::HStoreOp" do
   end
 
   it "#[] should return a PGArrayOp if given an array" do
-    @ds.literal(@h[%w'a'][0]).must_equal "(h -> ARRAY['a'])[0]"
+    @ds.literal(@h[%w'a'][0]).must_equal "((h -> ARRAY['a']))[0]"
   end
 
   it "#[] should not return a PGArrayOp if given an array but pg_array_op is not supported" do
@@ -58,11 +58,11 @@ describe "Sequel::Postgres::HStoreOp" do
   end
 
   it "#[] should return a PGArrayOp if given a PGArray" do
-    @ds.literal(@h[Sequel.pg_array(%w'a')][0]).must_equal "(h -> ARRAY['a'])[0]"
+    @ds.literal(@h[Sequel.pg_array(%w'a')][0]).must_equal "((h -> ARRAY['a']))[0]"
   end
 
   it "#[] should return a PGArrayOp if given a PGArrayOp" do
-    @ds.literal(@h[Sequel.pg_array_op(:a)][0]).must_equal "(h -> a)[0]"
+    @ds.literal(@h[Sequel.pg_array_op(:a)][0]).must_equal "((h -> a))[0]"
   end
 
   it "#[] should return a string expression" do
@@ -157,8 +157,8 @@ describe "Sequel::Postgres::HStoreOp" do
   end
 
   it "#keys and #akeys should return PGArrayOps" do
-    @ds.literal(@h.keys[0]).must_equal "akeys(h)[0]"
-    @ds.literal(@h.akeys[0]).must_equal "akeys(h)[0]"
+    @ds.literal(@h.keys[0]).must_equal "(akeys(h))[0]"
+    @ds.literal(@h.akeys[0]).must_equal "(akeys(h))[0]"
   end
 
   it "#populate should use the populate_record function" do
@@ -194,7 +194,7 @@ describe "Sequel::Postgres::HStoreOp" do
   end
 
   it "#to_array should return a PGArrayOp" do
-    @ds.literal(@h.to_array[0]).must_equal "hstore_to_array(h)[0]"
+    @ds.literal(@h.to_array[0]).must_equal "(hstore_to_array(h))[0]"
   end
 
   it "#to_matrix should use the hstore_to_matrix function" do
@@ -202,7 +202,7 @@ describe "Sequel::Postgres::HStoreOp" do
   end
 
   it "#to_matrix should return a PGArrayOp" do
-    @ds.literal(@h.to_matrix[0]).must_equal "hstore_to_matrix(h)[0]"
+    @ds.literal(@h.to_matrix[0]).must_equal "(hstore_to_matrix(h))[0]"
   end
 
   it "#values and #avals should use the avals function" do
@@ -211,8 +211,8 @@ describe "Sequel::Postgres::HStoreOp" do
   end
 
   it "#values and #avals should return PGArrayOps" do
-    @ds.literal(@h.values[0]).must_equal "avals(h)[0]"
-    @ds.literal(@h.avals[0]).must_equal "avals(h)[0]"
+    @ds.literal(@h.values[0]).must_equal "(avals(h))[0]"
+    @ds.literal(@h.avals[0]).must_equal "(avals(h))[0]"
   end
 
   it "should have Sequel.hstore_op return HStoreOp instances as-is" do

data/spec/extensions/pg_row_ops_spec.rb

@@ -18,11 +18,11 @@ describe "Sequel::Postgres::PGRowOp" do
   end
 
   it "#[] should support array access if not given an identifier" do
-    @db.literal(@a[:b][1]).must_equal "(a).b[1]"
+    @db.literal(@a[:b][1]).must_equal "((a).b)[1]"
   end
 
   it "#[] should be chainable with array access" do
-    @db.literal(@a[1][:b]).must_equal "(a[1]).b"
+    @db.literal(@a[1][:b]).must_equal "((a)[1]).b"
   end
 
   it "#splat should return a splatted argument inside parentheses" do

data/spec/extensions/sql_expr_spec.rb

@@ -15,7 +15,7 @@ describe "Sequel sql_expr extension" do
     @ds.literal(s+1).must_equal "(foo + 1)"
     @ds.literal(s & true).must_equal "(foo AND 't')"
     @ds.literal(s < 1).must_equal "(foo < 1)"
-    @ds.literal(s.sql_subscript(1)).must_equal "foo[1]"
+    @ds.literal(s.sql_subscript(1)).must_equal "(foo)[1]"
     @ds.literal(s.like('a')).must_equal "(foo LIKE 'a' ESCAPE '\\')"
     @ds.literal(s.as(:a)).must_equal "foo AS a"
     @ds.literal(s.cast(Integer)).must_equal "CAST(foo AS integer)"

data/spec/extensions/string_agg_spec.rb

@@ -85,6 +85,6 @@ describe "string_agg extension" do
     ds.literal(@sa1.cast(:b)).must_equal "CAST(string_agg(c, ',') AS b)"
     ds.literal(@sa1.desc).must_equal "string_agg(c, ',') DESC"
     ds.literal(@sa1 =~ /a/).must_equal "(string_agg(c, ',') ~ 'a')"
-    ds.literal(@sa1.sql_subscript(1)).must_equal "string_agg(c, ',')[1]"
+    ds.literal(@sa1.sql_subscript(1)).must_equal "(string_agg(c, ','))[1]"
   end
 end

data/spec/integration/dataset_test.rb

@@ -953,7 +953,7 @@ if DB.dataset.supports_window_functions?
           must_equal [{:sum=>110, :id=>1}, {:sum=>1100, :id=>2}, {:sum=>11000, :id=>3}, {:sum=>110000, :id=>4}, {:sum=>100000, :id=>5}, {:sum=>nil, :id=>6}]
       end
 
-      cspecify "should give correct results for aggregate window functions with offsets for RANGES", :mssql, [proc{DB.server_version < 110000}, :postgres] do
+      cspecify "should give correct results for aggregate window functions with offsets for RANGES", :mssql, :sqlite, [proc{DB.server_version < 110000}, :postgres] do
         @ds.select(:id){sum(:amount).over(:order=>:group_id, :frame=>{:type=>:range, :start=>1}).as(:sum)}.all.
           must_equal [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
         @ds.select(:id){sum(:amount).over(:order=>:group_id, :frame=>{:type=>:range, :start=>0, :end=>1}).as(:sum)}.all.

data/spec/integration/transaction_test.rb

@@ -82,8 +82,207 @@ describe "Database transactions" do
     end}.must_raise(Interrupt)
     @d.count.must_equal 0
   end 
+
+  it "should support rollback_on_exit" do
+    @db.transaction do
+      @d.insert(:name => 'abc', :value => 1)
+      @db.rollback_on_exit
+    end
+    @d.must_be_empty
+
+    catch(:foo) do
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.rollback_on_exit
+        throw :foo
+      end
+    end
+    @d.must_be_empty
+
+    lambda do
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.rollback_on_exit
+        return true
+      end
+    end
+    @d.must_be_empty
+
+    @db.transaction do
+      @d.insert(:name => 'abc', :value => 1)
+      @db.rollback_on_exit
+      @db.rollback_on_exit(:cancel=>true)
+    end
+    @d.count.must_equal 1
+
+    @d.delete
+    @db.transaction do
+      @d.insert(:name => 'abc', :value => 1)
+      @db.rollback_on_exit(:cancel=>true)
+    end
+    @d.count.must_equal 1
+
+    @d.delete
+    @db.transaction do
+      @d.insert(:name => 'abc', :value => 1)
+      @db.rollback_on_exit
+      @db.rollback_on_exit(:cancel=>true)
+      @db.rollback_on_exit
+    end
+    @d.must_be_empty
+  end
   
   if DB.supports_savepoints?
+    it "should support rollback_on_exit inside savepoints" do
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.transaction(:savepoint=>true) do
+          @d.insert(:name => 'def', :value => 2)
+          @db.rollback_on_exit
+        end
+      end
+      @d.must_be_empty
+
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.transaction(:savepoint=>true) do
+          @d.insert(:name => 'def', :value => 2)
+          @db.rollback_on_exit
+          @db.transaction(:savepoint=>true) do
+            @d.insert(:name => 'ghi', :value => 3)
+          end
+        end
+      end
+      @d.must_be_empty
+
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.transaction(:savepoint=>true) do
+          @d.insert(:name => 'def', :value => 2)
+          @db.transaction(:savepoint=>true) do
+            @db.rollback_on_exit
+            @d.insert(:name => 'ghi', :value => 3)
+          end
+        end
+      end
+      @d.must_be_empty
+    end
+
+    it "should support rollback_on_exit with :savepoint option" do
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.transaction(:savepoint=>true) do
+          @d.insert(:name => 'def', :value => 2)
+          @db.rollback_on_exit(:savepoint=>true)
+        end
+      end
+      @d.select_order_map(:value).must_equal [1]
+
+      @d.delete
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.transaction(:savepoint=>true) do
+          @d.insert(:name => 'def', :value => 2)
+          @db.rollback_on_exit(:savepoint=>true)
+          @db.transaction(:savepoint=>true) do
+            @db.rollback_on_exit(:savepoint=>true)
+            @d.insert(:name => 'ghi', :value => 3)
+          end
+        end
+      end
+      @d.select_order_map(:value).must_equal [1]
+    end
+
+    it "should support rollback_on_exit with :savepoint=>Integer" do
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.transaction(:savepoint=>true) do
+          @d.insert(:name => 'def', :value => 2)
+          @db.rollback_on_exit(:savepoint=>2)
+        end
+      end
+      @d.must_be_empty
+
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.transaction(:savepoint=>true) do
+          @d.insert(:name => 'def', :value => 2)
+          @db.rollback_on_exit(:savepoint=>3)
+        end
+      end
+      @d.must_be_empty
+
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.transaction(:savepoint=>true) do
+          @d.insert(:name => 'def', :value => 2)
+          @db.transaction(:savepoint=>true) do
+            @db.rollback_on_exit(:savepoint=>2)
+            @d.insert(:name => 'ghi', :value => 3)
+          end
+        end
+      end
+      @d.select_order_map(:value).must_equal [1]
+    end
+
+    it "should support rollback_on_exit with :savepoint=>Integer and :cancel" do
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.transaction(:savepoint=>true) do
+          @db.rollback_on_exit(:savepoint=>true)
+          @d.insert(:name => 'def', :value => 2)
+          @db.transaction(:savepoint=>true) do
+            @db.rollback_on_exit(:savepoint=>2, :cancel=>true)
+            @d.insert(:name => 'ghi', :value => 3)
+          end
+        end
+      end
+      @d.select_order_map(:value).must_equal [1, 2, 3]
+
+      @d.delete
+      @db.transaction do
+        @db.rollback_on_exit(:savepoint=>true)
+        @d.insert(:name => 'abc', :value => 1)
+        @db.transaction(:savepoint=>true) do
+          @db.rollback_on_exit(:savepoint=>true)
+          @d.insert(:name => 'def', :value => 2)
+          @db.transaction(:savepoint=>true) do
+            @db.rollback_on_exit(:savepoint=>3, :cancel=>true)
+            @d.insert(:name => 'ghi', :value => 3)
+          end
+        end
+      end
+      @d.select_order_map(:value).must_equal [1, 2, 3]
+
+      @d.delete
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.rollback_on_exit(:savepoint=>true)
+        @db.transaction(:savepoint=>true) do
+          @d.insert(:name => 'def', :value => 2)
+          @db.transaction(:savepoint=>true) do
+            @db.rollback_on_exit(:savepoint=>4, :cancel=>true)
+            @d.insert(:name => 'ghi', :value => 3)
+          end
+        end
+      end
+      @d.select_order_map(:value).must_equal [1, 2, 3]
+
+      @d.delete
+      @db.transaction do
+        @d.insert(:name => 'abc', :value => 1)
+        @db.transaction(:savepoint=>true) do
+          @db.rollback_on_exit(:savepoint=>2)
+          @d.insert(:name => 'def', :value => 2)
+          @db.transaction(:savepoint=>true) do
+            @db.rollback_on_exit(:savepoint=>2, :cancel=>true)
+            @d.insert(:name => 'ghi', :value => 3)
+          end
+        end
+      end
+      @d.must_be_empty
+    end
+
     it "should handle table_exists? failures inside transactions" do
       @db.transaction do
         @d.insert(:name => '1')

data/spec/model/associations_spec.rb

@@ -1084,6 +1084,37 @@ describe Sequel::Model, "one_to_one" do
     DB.sqls.must_equal []
   end
 
+  it "should have setter not unset reciprocal during save if reciprocal is the same as current" do
+    @c2.many_to_one :parent, :class => @c2, :key=>:parent_id
+    @c2.one_to_one :child, :class => @c2, :key=>:parent_id, :reciprocal=>:parent
+
+    d = @c2.new(:id => 1)
+    e = @c2.new(:id => 2)
+    e2 = @c2.new(:id => 3)
+    e3 = @c2.new(:id => 4)
+    d.associations[:parent] = e
+    e.associations[:child] = d
+    e2.associations[:child] = d
+    e3.associations[:child] = e
+    assoc = nil
+    d.define_singleton_method(:after_save) do
+      super()
+      assoc = associations
+    end
+
+    def e.set_associated_object_if_same?; true; end
+    e.child = d
+    assoc.must_equal(:parent=>e)
+
+    def e2.set_associated_object_if_same?; true; end
+    e2.child = e
+    assoc.must_equal(:parent=>nil)
+
+    d.associations.clear
+    e3.child = d
+    assoc.must_equal({})
+  end
+
   it "should not add associations methods directly to class" do
     @c2.one_to_one :parent, :class => @c2
     @c2.instance_methods.must_include(:parent)