sequel 4.31.0 → 4.32.0

data/spec/extensions/eager_each_spec.rb

@@ -26,7 +26,6 @@ describe "Sequel::Plugins::EagerEach" do
   it "should make #each on an eager_graph dataset do eager loading" do
     a = []
     ds = @c.eager_graph(:children)
-    ds._fetch = []
     ds._fetch = [{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}, {:id=>2, :parent_id=>nil, :children_id=>5, :children_parent_id=>2}, {:id=>2, :parent_id=>nil, :children_id=>6, :children_parent_id=>2}]
     ds.each{|c| a << c}
     a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
@@ -34,6 +33,31 @@ describe "Sequel::Plugins::EagerEach" do
     @c.db.sqls.must_equal ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)']
   end
 
+  it "should make #first on an eager dataset do eager loading" do
+    ds = @c.eager(:children)
+    ds._fetch = [{:id=>1, :parent_id=>nil}]
+    @c.dataset._fetch = [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}]
+    a = ds.first
+    a.values.must_equal(:id=>1, :parent_id=>nil)
+    a.associations[:children].must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)]
+    @c.db.sqls.must_equal ['SELECT * FROM items LIMIT 1','SELECT * FROM items WHERE (items.parent_id IN (1))'] 
+  end
+
+  it "should make #first on an eager_graph dataset do eager loading" do
+    ds = @c.eager_graph(:children)
+    ds._fetch = [[{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}], [{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}]]
+    a = ds.first
+    a.values.must_equal(:id=>1, :parent_id=>nil)
+    a.associations[:children].must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)]
+    @c.db.sqls.must_equal ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id) LIMIT 1',
+      'SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id) WHERE (items.id = 1)']
+  end
+
+  it "should make #first on a non-eager dataset work correctly" do
+    @c.dataset._fetch = [{:id=>1, :parent_id=>nil}]
+    @c.first.must_equal @c.load(:id=>1, :parent_id=>nil)
+  end
+
   it "should not attempt to eager load when getting the columns" do
     ds = @c.eager(:children)
     def ds.all; raise; end

data/spec/extensions/no_auto_literal_strings_spec.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "no_auto_literal_strings extension" do
+  before do
+    @ds = Sequel.mock[:t].extension(:no_auto_literal_strings)
+  end
+
+  it "should raise exception for plain strings in filter methods" do
+    proc{@ds.where("a")}.must_raise Sequel::Error
+    proc{@ds.having("a")}.must_raise Sequel::Error
+    proc{@ds.filter("a")}.must_raise Sequel::Error
+    proc{@ds.exclude_where("a")}.must_raise Sequel::Error
+    proc{@ds.exclude_having("a")}.must_raise Sequel::Error
+    proc{@ds.and("a")}.must_raise Sequel::Error
+    proc{@ds.where(:a).or("a")}.must_raise Sequel::Error
+    proc{@ds.first("a")}.must_raise Sequel::Error
+    proc{@ds.order(:a).last("a")}.must_raise Sequel::Error
+    proc{@ds["a"]}.must_raise Sequel::Error
+  end
+  
+  it "should raise exception for plain strings arrays in filter methods" do
+    proc{@ds.where(["a"])}.must_raise Sequel::Error
+  end
+
+  it "should handle explicit literal strings in filter methods" do
+    @ds.where(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
+    @ds.having(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t HAVING (a)'
+    @ds.filter(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
+    @ds.exclude_where(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE NOT (a)'
+    @ds.exclude_having(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t HAVING NOT (a)'
+    @ds.and(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
+    @ds.where(:a).or(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a OR (a))'
+    @ds.first(Sequel.lit("a"))
+    @ds.order(:a).last(Sequel.lit("a"))
+    @ds[Sequel.lit("a")]
+    @ds.db.sqls.must_equal ["SELECT * FROM t WHERE (a) LIMIT 1",
+                            "SELECT * FROM t WHERE (a) ORDER BY a DESC LIMIT 1",
+                            "SELECT * FROM t WHERE (a) LIMIT 1"]
+  end
+  
+  it "should handle literal strings in arrays in filter methods" do
+    @ds.where([Sequel.lit("a")]).sql.must_equal 'SELECT * FROM t WHERE (a)'
+  end
+
+  it "should handle other objects in filter methods" do
+    @ds.where(:a).sql.must_equal 'SELECT * FROM t WHERE a'
+  end
+  
+  it "should raise exception for plain strings in update methods" do
+    proc{@ds.update("a = a + 1")}.must_raise Sequel::Error
+    proc{@ds.update_sql("a = a + 1")}.must_raise Sequel::Error
+  end
+  
+  it "should handle explicit literal strings in update methods" do
+    @ds.update_sql(Sequel.lit("a = a + 1")).must_equal "UPDATE t SET a = a + 1"
+    @ds.update(Sequel.lit("a = a + 1"))
+    @ds.db.sqls.must_equal ["UPDATE t SET a = a + 1"]
+  end
+  
+  it "should handle other objects in update methods" do
+    @ds.update_sql(:a=>:a).must_equal "UPDATE t SET a = a"
+    @ds.update(:a=>:a)
+    @ds.db.sqls.must_equal ["UPDATE t SET a = a"]
+  end
+end

data/spec/extensions/pg_range_spec.rb

@@ -38,6 +38,7 @@ describe "pg_range extension" do
     @db.literal(@R.new(1, nil)).must_equal "'[1,]'"
     @db.literal(@R.new(1, 2, :db_type=>'int8range')).must_equal "int8range(1,2,'[]')"
     @db.literal(@R.new(nil, nil, :empty=>true)).must_equal "'empty'"
+    @db.literal(@R.new(nil, nil, :empty=>true, :db_type=>'int8range')).must_equal "'empty'::int8range"
     @db.literal(@R.new("", 2)).must_equal "'[\"\",2]'"
   end
 

data/spec/extensions/spec_helper.rb

@@ -1,15 +1,15 @@
 require 'rubygems'
 
-gem 'minitest'
-require 'minitest/autorun'
-require 'minitest/hooks/default'
-require 'minitest/shared_description'
-
 if ENV['COVERAGE']
   require File.join(File.dirname(File.expand_path(__FILE__)), "../sequel_coverage")
   SimpleCov.sequel_coverage(:filter=>%r{lib/sequel/(extensions|plugins)/\w+\.rb\z})
 end
 
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/hooks/default'
+require 'minitest/shared_description'
+
 unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
   require 'sequel'

data/spec/extensions/tactical_eager_loading_spec.rb

@@ -1,8 +1,22 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::TacticalEagerLoading" do
+  def sql_match(*args)
+    sqls = DB.sqls
+    sqls.length.must_equal args.length
+    sqls.zip(args).each do |is, should|
+      if should.is_a?(Regexp)
+        is.must_match should
+      else
+        is.must_equal should
+      end
+    end
+  end
+  
+  attr_reader :ts
+
   before do
-    class ::TacticalEagerLoadingModel < Sequel::Model
+    class ::TacticalEagerLoadingModel < Sequel::Model(:t)
       plugin :tactical_eager_loading
       columns :id, :parent_id
       many_to_one :parent, :class=>self
@@ -22,61 +36,101 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
     @c = ::TacticalEagerLoadingModel
     @ds = TacticalEagerLoadingModel.dataset
     DB.reset
+    @ts = @c.all
+    sql_match('SELECT * FROM t')
   end
   after do
     Object.send(:remove_const, :TacticalEagerLoadingModel)
+    sql_match
   end
 
   it "Dataset#all should set the retrieved_by and retrieved_with attributes" do
-    ts = @c.all
     ts.map{|x| [x.retrieved_by, x.retrieved_with]}.must_equal [[@ds,ts], [@ds,ts], [@ds,ts], [@ds,ts]]
   end
 
   it "Dataset#all shouldn't raise an error if a Sequel::Model instance is not returned" do
     @c.naked.all
+    sql_match('SELECT * FROM t')
   end
 
   it "association getter methods should eagerly load the association if the association isn't cached" do
-    DB.sqls.length.must_equal 0
-    ts = @c.all
-    DB.sqls.length.must_equal 1
     ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
-    DB.sqls.length.must_equal 1
+    sql_match(/\ASELECT \* FROM t WHERE \(t\.id IN \(10[12], 10[12]\)\)\z/)
     ts.map{|x| x.children}.must_equal [[], [], [ts[0]], [ts[1]]]
-    DB.sqls.length.must_equal 1
+    sql_match(/\ASELECT \* FROM t WHERE \(t\.parent_id IN/)
   end
 
   it "association getter methods should not eagerly load the association if the association is cached" do
-    DB.sqls.length.must_equal 0
-    ts = @c.all
-    DB.sqls.length.must_equal 1
     ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
+    sql_match(/\ASELECT \* FROM t WHERE \(t\.id IN \(10[12], 10[12]\)\)\z/)
     def @ds.eager_load(*) raise end
     ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
   end
 
+  it "association getter methods should not eagerly load the association if a block is given" do
+    ts.map{|x| x.parent{|ds| ds}}.must_equal [ts[2], ts[3], nil, nil]
+    sql_match('SELECT * FROM t WHERE (t.id = 101) LIMIT 1', 'SELECT * FROM t WHERE (t.id = 102) LIMIT 1')
+  end
+
+  it "association getter methods should not eagerly load the association if a callback proc is given" do
+    ts.map{|x| x.parent(:callback=>proc{|ds| ds})}.must_equal [ts[2], ts[3], nil, nil]
+    sql_match('SELECT * FROM t WHERE (t.id = 101) LIMIT 1', 'SELECT * FROM t WHERE (t.id = 102) LIMIT 1')
+  end
+
+  it "association getter methods should not eagerly load the association if true is passed" do
+    ts.map{|x| x.parent(true)}.must_equal [ts[2], ts[3], nil, nil]
+    sql_match('SELECT * FROM t WHERE id = 101', 'SELECT * FROM t WHERE id = 102')
+  end
+
+  it "association getter methods should not eagerly load the association if :reload=>true is passed" do
+    ts.map{|x| x.parent(:reload=>true)}.must_equal [ts[2], ts[3], nil, nil]
+    sql_match('SELECT * FROM t WHERE id = 101', 'SELECT * FROM t WHERE id = 102')
+  end
+
+  it "association getter methods should eagerly reload the association if :eager_reload=>true is passed" do
+    ts.first.parent(:reload=>true)
+    sql_match('SELECT * FROM t WHERE id = 101')
+    ts.map{|x| x.associations.fetch(:parent, 1)}.must_equal [ts[2], 1, 1, 1]
+    ts.first.parent(:eager_reload=>true)
+    sql_match(/\ASELECT \* FROM t WHERE \(t\.id IN \(10[12], 10[12]\)\)\z/)
+    ts.map{|x| x.associations.fetch(:parent, 1)}.must_equal [ts[2], ts[3], nil, nil]
+  end
+
+  it "association getter methods should support eagerly loading dependent associations via :eager" do
+    parents = ts.map{|x| x.parent(:eager=>:children)}
+    sql_match(/\ASELECT \* FROM t WHERE \(t\.id IN \(10[12], 10[12]\)\)\z/, /\ASELECT \* FROM t WHERE \(t\.parent_id IN/)
+    parents.must_equal [ts[2], ts[3], nil, nil]
+    parents[0..1].map{|x| x.children}.must_equal [[ts[0]], [ts[1]]]
+  end
+
+  it "association getter methods should support eager callbacks via :eager" do
+    parents = ts.map{|x| x.parent(:eager=>proc{|ds| ds.where{name > 'M'}.eager(:children)})}
+    sql_match(/\ASELECT \* FROM t WHERE \(\(t\.id IN \(10[12], 10[12]\)\) AND \(name > 'M'\)\)\z/, /\ASELECT \* FROM t WHERE \(t\.parent_id IN/)
+    parents.must_equal [ts[2], ts[3], nil, nil]
+    parents[0..1].map{|x| x.children}.must_equal [[ts[0]], [ts[1]]]
+  end
+
   it "should handle case where an association is valid on an instance, but not on all instances" do
     c = Class.new(@c)
     c.many_to_one :parent2, :class=>@c, :key=>:parent_id
     @c.dataset.row_proc = proc{|r| (r[:parent_id] == 101 ? c : @c).call(r)}
     @c.all{|x| x.parent2 if x.is_a?(c)}
+    sql_match('SELECT * FROM t', 'SELECT * FROM t WHERE id = 101')
   end
 
   it "association getter methods should not eagerly load the association if an instance is frozen" do
-    ts = @c.all
     ts.first.freeze
-    DB.sqls.length.must_equal 1
     ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
-    DB.sqls.length.must_equal 2
+    sql_match('SELECT * FROM t WHERE id = 101', 'SELECT * FROM t WHERE (t.id IN (102))')
     ts.map{|x| x.children}.must_equal [[], [], [ts[0]], [ts[1]]]
-    DB.sqls.length.must_equal 2
+    sql_match('SELECT * FROM t WHERE (t.parent_id = 1)', /\ASELECT \* FROM t WHERE \(t\.parent_id IN/)
     ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
-    DB.sqls.length.must_equal 1
+    sql_match('SELECT * FROM t WHERE id = 101')
     ts.map{|x| x.children}.must_equal [[], [], [ts[0]], [ts[1]]]
-    DB.sqls.length.must_equal 1
+    sql_match('SELECT * FROM t WHERE (t.parent_id = 1)')
   end
 
   it "#marshallable should make marshalling not fail" do
-    Marshal.dump(@c.all.map{|x| x.marshallable!})
+    Marshal.dump(ts.map{|x| x.marshallable!})
   end
 end

data/spec/integration/associations_test.rb

@@ -1501,22 +1501,83 @@ BasicRegularAndCompositeKeyAssociations = shared_description do
     @album.tags.must_equal []
     @album.alias_tags.must_equal []
     @tag.albums.must_equal []
+    unless @no_many_through_many
+      @album.first_tag.must_equal nil
+    end
   end
 
-  it "should have add and set methods work any associated objects" do
+  it "should have set methods work" do
+    # many to one
     @album.update(:artist => @artist)
+    @album.reload.artist.must_equal @artist
+    @album.update(:artist => nil)
+    @album.reload.artist.must_equal nil
+
+    # one to one
+    @artist.update(:first_album => @album)
+    @artist.reload.first_album.must_equal @album
+    @artist.update(:first_album => nil)
+    @artist.reload.first_album.must_equal nil
+
+    unless @no_many_through_many
+      tag = @pr.call.last
+      # one through one
+      @album.update(:first_tag => @tag)
+      @album.reload.first_tag.must_equal @tag
+      @album.update(:first_tag => @tag)
+      @album.reload.first_tag.must_equal @tag
+      @album.update(:first_tag => tag)
+      @album.reload.first_tag.must_equal tag
+      @album.update(:first_tag => nil)
+      @album.reload.first_tag.must_equal nil
+      @album.update(:first_tag => nil)
+      @album.reload.first_tag.must_equal nil
+
+      # one through one with alias
+      @album.update(:alias_t_tag => @tag)
+      @album.reload.alias_t_tag.must_equal @tag
+      @album.update(:alias_t_tag => nil)
+      @album.reload.alias_t_tag.must_equal nil
+    end
+  end
+
+  it "should have add and remove methods work" do
+    # one to many
+    @artist.add_album(@album)
+    @artist.reload.albums.must_equal [@album]
+    @artist.remove_album(@album)
+    @artist.reload.albums.must_equal []
+
+    # many to many 
     @album.add_tag(@tag)
-    
-    @album.reload
-    @artist.reload
-    @tag.reload
-    
-    @album.artist.must_equal @artist
-    @artist.first_album.must_equal @album
-    @artist.albums.must_equal [@album]
-    @album.tags.must_equal [@tag]
+    @album.reload.tags.must_equal [@tag]
+    @tag.reload.albums.must_equal [@album]
     @album.alias_tags.must_equal [@tag]
-    @tag.albums.must_equal [@album]
+    @album.remove_tag(@tag)
+    @album.reload.tags.must_equal []
+
+    # many to many with alias
+    @album.add_alias_tag(@tag)
+    @album.reload.alias_tags.must_equal [@tag]
+    @album.remove_alias_tag(@tag)
+    @album.reload.alias_tags.must_equal []
+  end
+  
+  it "should have remove_all methods work" do
+    # one to many
+    @artist.add_album(@album)
+    @artist.remove_all_albums
+    @artist.reload.albums.must_equal []
+
+    # many to many 
+    @album.add_tag(@tag)
+    @album.remove_all_tags
+    @album.reload.tags.must_equal []
+
+    # many to many with alias
+    @album.add_alias_tag(@tag)
+    @album.remove_all_alias_tags
+    @album.reload.alias_tags.must_equal []
   end
   
   it "should work correctly with prepared_statements_association plugin" do
@@ -1534,6 +1595,9 @@ BasicRegularAndCompositeKeyAssociations = shared_description do
     @album.tags.must_equal [@tag]
     @album.alias_tags.must_equal [@tag]
     @tag.albums.must_equal [@album]
+    unless @no_many_through_many
+      @album.first_tag.must_equal @tag
+    end
   end
 
   it "should have working dataset associations" do
@@ -1599,55 +1663,6 @@ BasicRegularAndCompositeKeyAssociations = shared_description do
     Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).albums.filter(Album.qualified_primary_key_hash(@album.pk)).tags.all.must_equal []
   end
 
-  it "should have remove methods work" do
-    @album.update(:artist => @artist)
-    @album.add_tag(@tag)
-    
-    @album.update(:artist => nil)
-    @album.remove_tag(@tag)
-
-    @album.add_alias_tag(@tag)
-    @album.remove_alias_tag(@tag)
-    
-    @album.reload
-    @artist.reload
-    @tag.reload
-    
-    @album.artist.must_equal nil
-    @artist.albums.must_equal []
-    @album.tags.must_equal []
-    @tag.albums.must_equal []
-
-    @album.add_alias_tag(@tag)
-    @album.remove_alias_tag(@tag)
-
-    @album.reload
-    @album.alias_tags.must_equal []
-  end
-  
-  it "should have remove_all methods work" do
-    @artist.add_album(@album)
-    @album.add_tag(@tag)
-    
-    @album.remove_all_tags
-    @artist.remove_all_albums
-    
-    @album.reload
-    @artist.reload
-    @tag.reload
-    
-    @album.artist.must_equal nil
-    @artist.albums.must_equal []
-    @album.tags.must_equal []
-    @tag.albums.must_equal []
-
-    @album.add_alias_tag(@tag)
-    @album.remove_all_alias_tags
-
-    @album.reload
-    @album.alias_tags.must_equal []
-  end
-  
   it "should eager load via eager correctly" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
@@ -1684,8 +1699,6 @@ BasicRegularAndCompositeKeyAssociations = shared_description do
 end
 
 RegularAndCompositeKeyAssociations = shared_description do
-  include BasicRegularAndCompositeKeyAssociations
-
   describe "when filtering/excluding by associations when joining" do
     def self_join(c)
       c.join(Sequel.as(c.table_name, :b), Array(c.primary_key).zip(Array(c.primary_key))).select_all(c.table_name)
@@ -1884,6 +1897,7 @@ describe "Sequel::Model Simple Associations" do
     @db.drop_table?(:albums_tags, :tags, :albums, :artists)
   end
   
+  include BasicRegularAndCompositeKeyAssociations
   include RegularAndCompositeKeyAssociations
 
   describe "with :correlated_subquery limit strategy" do
@@ -2160,6 +2174,7 @@ describe "Sequel::Model Composite Key Associations" do
     @db.drop_table?(:albums_tags, :tags, :albums, :artists)
   end
 
+  include BasicRegularAndCompositeKeyAssociations
   include RegularAndCompositeKeyAssociations
 
   describe "with :correlated_subquery limit strategy" do