sequel 4.45.0 → 4.46.0

data/spec/extensions/graph_each_spec.rb

@@ -38,7 +38,7 @@ describe Sequel::Dataset, " graphing" do
 
     @ds1.graph(@ds2, :x=>:id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}}]
     @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
-    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}]
+    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>Sequel[:points][:id]}, :table_alias=>:graph).all.must_equal [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}]
   end
 
   it "#graph_each should split the result set into component tables when using first" do
@@ -48,7 +48,7 @@ describe Sequel::Dataset, " graphing" do
 
     @ds1.graph(@ds2, :x=>:id).first.must_equal(:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7})
     @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).first.must_equal(:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12})
-    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph).first.must_equal(:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11})
+    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>Sequel[:points][:id]}, :table_alias=>:graph).first.must_equal(:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11})
   end
 
   it "#graph_each should give a nil value instead of a hash when all values for a table are nil" do

data/spec/extensions/identifier_mangling_spec.rb

@@ -24,7 +24,8 @@ describe "identifier_mangling extension" do
   end
 
   it "should upcase on input and downcase on output by default" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
+    # SEQUEL5: Remove :identifier_mangling=>false
+    db = Sequel::Database.new(:identifier_mangling=>false).extension(:identifier_mangling)
     db.send(:identifier_input_method_default).must_equal :upcase
     db.send(:identifier_output_method_default).must_equal :downcase
   end
@@ -141,9 +142,9 @@ describe "identifier_mangling extension" do
   deprecated "should respect the quote_indentifiers_default method if Sequel.quote_identifiers = nil" do
     Sequel.quote_identifiers = nil
     Sequel::Database.new.extension(:identifier_mangling).quote_identifiers?.must_equal true
-    x = Class.new(Sequel::Database){def quote_identifiers_default; false end}
+    x = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def quote_identifiers_default; false end}
     x.new.extension(:identifier_mangling).quote_identifiers?.must_equal false
-    y = Class.new(Sequel::Database){def quote_identifiers_default; true end}
+    y = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def quote_identifiers_default; true end}
     y.new.extension(:identifier_mangling).quote_identifiers?.must_equal true
   end
   
@@ -151,9 +152,9 @@ describe "identifier_mangling extension" do
     class Sequel::Database
       @identifier_input_method = nil
     end
-    x = Class.new(Sequel::Database){def identifier_input_method_default; :downcase end}
+    x = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_input_method_default; :downcase end}
     x.new.extension(:identifier_mangling).identifier_input_method.must_equal :downcase
-    y = Class.new(Sequel::Database){def identifier_input_method_default; :camelize end}
+    y = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_input_method_default; :camelize end}
     y.new.extension(:identifier_mangling).identifier_input_method.must_equal :camelize
   end
   
@@ -161,9 +162,9 @@ describe "identifier_mangling extension" do
     class Sequel::Database
       @identifier_output_method = nil
     end
-    x = Class.new(Sequel::Database){def identifier_output_method_default; :upcase end}
+    x = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_output_method_default; :upcase end}
     x.new.extension(:identifier_mangling).identifier_output_method.must_equal :upcase
-    y = Class.new(Sequel::Database){def identifier_output_method_default; :underscore end}
+    y = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_output_method_default; :underscore end}
     y.new.extension(:identifier_mangling).identifier_output_method.must_equal :underscore
   end
 end
@@ -315,7 +316,7 @@ describe "identifier_mangling extension" do
       Sequel.mock(:host=>'oracle')[:a].limit(1).sql.must_equal 'SELECT * FROM (SELECT * FROM "A") "T1" WHERE (ROWNUM <= 1)'
       Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM \"a\" WHERE (to_tsvector(CAST('simple' AS regconfig), (COALESCE(\"b\", ''))) @@ to_tsquery(CAST('simple' AS regconfig), 'c'))"
       Sequel.mock(:host=>'sqlanywhere').from(:a).offset(1).sql.must_equal 'SELECT TOP 2147483647 START AT (1 + 1) * FROM "A"'
-      Sequel.mock(:host=>'sqlite')[:a___b].sql.must_equal "SELECT * FROM `a` AS 'b'"
+      Sequel.mock(:host=>'sqlite')[Sequel[:a].as(:b)].sql.must_equal "SELECT * FROM `a` AS 'b'"
     ensure
       deprecated do
         Sequel.quote_identifiers = qi
@@ -341,7 +342,12 @@ describe Sequel::Model, ".[] optimization" do
     @c.simple_table.must_equal '"ba"'
     @c.set_primary_key :cd
     @c.simple_pk.must_equal '"dc"'
+    @c.set_dataset ds.from(Sequel[:ef][:gh])
+    @c.simple_table.must_equal '"fe"."hg"'
+  end
 
+  with_symbol_splitting "should have simple_pk and simple_table respect dataset's identifier input methods when using splittable symbols" do
+    ds = @db.from(:ab).with_identifier_input_method(:reverse)
     @c.set_dataset ds.from(:ef__gh)
     @c.simple_table.must_equal '"fe"."hg"'
   end

data/spec/extensions/inverted_subsets_spec.rb

@@ -4,21 +4,21 @@ describe "Sequel::Plugins::InvertedSubsets" do
   it "should add an inverted subset method which inverts the condition" do
     c = Class.new(Sequel::Model(:a))
     c.plugin :inverted_subsets
-    c.subset(:published, :published => true)
+    c.dataset_module{subset(:published, :published => true)}
     c.not_published.sql.must_equal 'SELECT * FROM a WHERE (published IS NOT TRUE)'
   end
 
   it "should support a configuration block to customise the inverted method name" do
     c = Class.new(Sequel::Model(:a))
     c.plugin(:inverted_subsets){|name| "exclude_#{name}"}
-    c.subset(:published, :published => true)
+    c.dataset_module{where(:published, :published => true)}
     c.exclude_published.sql.must_equal 'SELECT * FROM a WHERE (published IS NOT TRUE)'
   end
 
   it "should chain to existing dataset" do
     c = Class.new(Sequel::Model(:a))
     c.plugin :inverted_subsets
-    c.subset(:published, :published => true)
+    c.dataset_module{where(:published, :published => true)}
     c.where(1=>0).not_published.sql.must_equal 'SELECT * FROM a WHERE ((1 = 0) AND (published IS NOT TRUE))'
   end
 
@@ -27,7 +27,7 @@ describe "Sequel::Plugins::InvertedSubsets" do
     c.plugin(:inverted_subsets){|name| "exclude_#{name}"}
     c = Class.new(c)
     c.dataset = :a
-    c.subset(:published, :published => true)
+    c.dataset_module{subset(:published, :published => true)}
     c.exclude_published.sql.must_equal 'SELECT * FROM a WHERE (published IS NOT TRUE)'
   end
 end

data/spec/extensions/lazy_attributes_spec.rb

@@ -63,6 +63,13 @@ describe "Sequel::Plugins::LazyAttributes" do
   end
 
   it "should handle lazy attributes that are qualified in the selection" do
+    @c.set_dataset(@ds.select(Sequel[:la][:id], Sequel[:la][:blah]))
+    @c.dataset.sql.must_equal 'SELECT la.id, la.blah FROM la'
+    @c.plugin :lazy_attributes, :blah
+    @c.dataset.sql.must_equal 'SELECT la.id FROM la'
+  end
+  
+  with_symbol_splitting "should handle lazy attributes that are qualified in the selection using symbol splitting" do
     @c.set_dataset(@ds.select(:la__id, :la__blah))
     @c.dataset.sql.must_equal 'SELECT la.id, la.blah FROM la'
     @c.plugin :lazy_attributes, :blah

data/spec/extensions/many_through_many_spec.rb

@@ -62,7 +62,7 @@ describe Sequel::Model, "many_through_many" do
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup" do
     @c1.dataset = @c1.dataset.with_fetch(:id=>1)
     @c2.dataset = @c2.dataset.with_fetch(:id=>4, :x_foreign_key_x=>1)
-    @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_loading_predicate_key=>Sequel./(:albums_artists__artist_id, 3)
+    @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_loading_predicate_key=>(Sequel[:albums_artists][:artist_id] / 3)
     a = @c1.eager(:tags).all
     a.must_equal [@c1.load(:id => 1)]
     DB.sqls.must_equal ['SELECT * FROM artists', "SELECT tags.*, (albums_artists.artist_id / 3) AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((albums_artists.artist_id / 3) IN (1))"]
@@ -70,6 +70,20 @@ describe Sequel::Model, "many_through_many" do
   end
   
   it "should handle schema qualified tables" do
+    @c1.many_through_many :tags, :through=>[[Sequel[:myschema][:albums_artists], :artist_id, :album_id], [Sequel[:myschema][:albums], :id, :id], [Sequel[:myschema][:albums_tags], :album_id, :tag_id]]
+    @c1.load(:id=>1).tags_dataset.sql.must_equal "SELECT tags.* FROM tags INNER JOIN myschema.albums_tags ON (myschema.albums_tags.tag_id = tags.id) INNER JOIN myschema.albums ON (myschema.albums.id = myschema.albums_tags.album_id) INNER JOIN myschema.albums_artists ON (myschema.albums_artists.album_id = myschema.albums.id) WHERE (myschema.albums_artists.artist_id = 1)"
+
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1)
+    @c2.dataset = @c2.dataset.with_fetch(:id=>4, :x_foreign_key_x=>1)
+    a = @c1.eager(:tags).all
+    a.must_equal [@c1.load(:id => 1)]
+    DB.sqls.must_equal ['SELECT * FROM artists', "SELECT tags.*, myschema.albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN myschema.albums_tags ON (myschema.albums_tags.tag_id = tags.id) INNER JOIN myschema.albums ON (myschema.albums.id = myschema.albums_tags.album_id) INNER JOIN myschema.albums_artists ON (myschema.albums_artists.album_id = myschema.albums.id) WHERE (myschema.albums_artists.artist_id IN (1))"]
+
+    Tag.dataset.columns(:id, :h1, :h2)
+    @c1.eager_graph(:tags).sql.must_equal 'SELECT artists.id, tags.id AS tags_id, tags.h1, tags.h2 FROM artists LEFT OUTER JOIN myschema.albums_artists AS albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN myschema.albums AS albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN myschema.albums_tags AS albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)'
+  end
+  
+  with_symbol_splitting "should handle schema qualified table symbols" do
     @c1.many_through_many :tags, :through=>[[:myschema__albums_artists, :artist_id, :album_id], [:myschema__albums, :id, :id], [:myschema__albums_tags, :album_id, :tag_id]]
     @c1.load(:id=>1).tags_dataset.sql.must_equal "SELECT tags.* FROM tags INNER JOIN myschema.albums_tags ON (myschema.albums_tags.tag_id = tags.id) INNER JOIN myschema.albums ON (myschema.albums.id = myschema.albums_tags.album_id) INNER JOIN myschema.albums_artists ON (myschema.albums_artists.album_id = myschema.albums.id) WHERE (myschema.albums_artists.artist_id = 1)"
 
@@ -335,7 +349,7 @@ describe Sequel::Model, "many_through_many" do
     n.tags_dataset.sql.must_equal 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((a = 32) AND (albums_artists.artist_id = 1234))'
     n.tags.must_equal [@c2.load(:id=>1)]
 
-    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>['a = ?', 42]
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>Sequel.lit('a = ?', 42)
     n = @c1.load(:id => 1234)
     n.tags_dataset.sql.must_equal 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((a = 42) AND (albums_artists.artist_id = 1234))'
     n.tags.must_equal [@c2.load(:id=>1)]
@@ -363,7 +377,7 @@ describe Sequel::Model, "many_through_many" do
   end
   
   it "should support an array for the select option" do
-    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[Sequel::SQL::ColumnAll.new(:tags), :albums__name]
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[Sequel::SQL::ColumnAll.new(:tags), Sequel[:albums][:name]]
     n = @c1.load(:id => 1234)
     n.tags_dataset.sql.must_equal 'SELECT tags.*, albums.name FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id = 1234)'
     n.tags.must_equal [@c2.load(:id=>1)]
@@ -386,7 +400,7 @@ describe Sequel::Model, "many_through_many" do
   end
 
   it "should support a :dataset option that is used instead of the default" do
-    @c1.many_through_many :tags, [[:a, :b, :c]], :dataset=>proc{Tag.join(:albums_tags, [:tag_id]).join(:albums, [:album_id]).join(:albums_artists, [:album_id]).filter(:albums_artists__artist_id=>id)}
+    @c1.many_through_many :tags, [[:a, :b, :c]], :dataset=>proc{Tag.join(:albums_tags, [:tag_id]).join(:albums, [:album_id]).join(:albums_artists, [:album_id]).filter(Sequel[:albums_artists][:artist_id]=>id)}
     n = @c1.load(:id => 1234)
     n.tags_dataset.sql.must_equal 'SELECT tags.* FROM tags INNER JOIN albums_tags USING (tag_id) INNER JOIN albums USING (album_id) INNER JOIN albums_artists USING (album_id) WHERE (albums_artists.artist_id = 1234)'
     n.tags.must_equal [@c2.load(:id=>1)]
@@ -839,7 +853,7 @@ describe "many_through_many eager loading methods" do
   end
 
   it "should respect the association's :select option" do
-    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>:tags__name
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>Sequel[:tags][:name]
     a = @c1.eager(:tags).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -1103,17 +1117,22 @@ describe "many_through_many eager loading methods" do
 
   it "should respect the association's :order" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :order=>[:blah1, :blah2]
-    @c1.order(:artists__blah2, :artists__blah3).eager_graph(:tags).sql.must_equal 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3, tags.blah1, tags.blah2'
+    @c1.order(Sequel[:artists][:blah2], Sequel[:artists][:blah3]).eager_graph(:tags).sql.must_equal 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3, tags.blah1, tags.blah2'
   end
 
-  it "should only qualify unqualified symbols, identifiers, or ordered versions in association's :order" do
+  with_symbol_splitting "should not qualify qualified symbols" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :order=>[Sequel.identifier(:blah__id), Sequel.identifier(:blah__id).desc, Sequel.desc(:blah__id), :blah__id, :album_id, Sequel.desc(:album_id), 1, Sequel.lit('RANDOM()'), Sequel.qualify(:b, :a)]
     @c1.order(:artists__blah2, :artists__blah3).eager_graph(:tags).sql.must_equal 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3, tags.blah__id, tags.blah__id DESC, blah.id DESC, blah.id, tags.album_id, tags.album_id DESC, 1, RANDOM(), b.a'
   end
 
+  it "should only qualify symbols, identifiers, or ordered versions in association's :order" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :order=>[Sequel.identifier(:blah__id), Sequel.identifier(:blah__id).desc, Sequel.desc(Sequel[:blah][:id]), Sequel[:blah][:id], :album_id, Sequel.desc(:album_id), 1, Sequel.lit('RANDOM()'), Sequel.qualify(:b, :a)]
+    @c1.order(Sequel[:artists][:blah2], Sequel[:artists][:blah3]).eager_graph(:tags).sql.must_equal 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3, tags.blah__id, tags.blah__id DESC, blah.id DESC, blah.id, tags.album_id, tags.album_id DESC, 1, RANDOM(), b.a'
+  end
+
   it "should not respect the association's :order if :order_eager_graph is false" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :order=>[:blah1, :blah2], :order_eager_graph=>false
-    @c1.order(:artists__blah2, :artists__blah3).eager_graph(:tags).sql.must_equal 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3'
+    @c1.order(Sequel[:artists][:blah2], Sequel[:artists][:blah3]).eager_graph(:tags).sql.must_equal 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3'
   end
 
   it "should add the associations :order for multiple associations" do
@@ -1215,7 +1234,7 @@ describe Sequel::Model, "one_through_many" do
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup" do
     @c1.dataset = @c1.dataset.with_fetch(:id=>1)
     @c2.dataset = @c2.dataset.with_fetch(:id=>4, :x_foreign_key_x=>1)
-    @c1.one_through_many :tag, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_loading_predicate_key=>Sequel./(:albums_artists__artist_id, 3)
+    @c1.one_through_many :tag, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_loading_predicate_key=>(Sequel[:albums_artists][:artist_id] / 3)
     a = @c1.eager(:tag).all
     a.must_equal [@c1.load(:id => 1)]
     DB.sqls.must_equal ['SELECT * FROM artists', "SELECT tags.*, (albums_artists.artist_id / 3) AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((albums_artists.artist_id / 3) IN (1))"]
@@ -1458,7 +1477,7 @@ describe Sequel::Model, "one_through_many" do
     n.tag_dataset.sql.must_equal 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((a = 32) AND (albums_artists.artist_id = 1234)) LIMIT 1'
     n.tag.must_equal @c2.load(:id=>1)
 
-    @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>['a = ?', 42]
+    @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>Sequel.lit('a = ?', 42)
     n = @c1.load(:id => 1234)
     n.tag_dataset.sql.must_equal 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((a = 42) AND (albums_artists.artist_id = 1234)) LIMIT 1'
     n.tag.must_equal @c2.load(:id=>1)
@@ -1486,7 +1505,7 @@ describe Sequel::Model, "one_through_many" do
   end
   
   it "should support an array for the select option" do
-    @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[Sequel::SQL::ColumnAll.new(:tags), :albums__name]
+    @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[Sequel::SQL::ColumnAll.new(:tags), Sequel[:albums][:name]]
     n = @c1.load(:id => 1234)
     n.tag_dataset.sql.must_equal 'SELECT tags.*, albums.name FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id = 1234) LIMIT 1'
     n.tag.must_equal @c2.load(:id=>1)
@@ -1509,7 +1528,7 @@ describe Sequel::Model, "one_through_many" do
   end
 
   it "should support a :dataset option that is used instead of the default" do
-    @c1.one_through_many :tag, [[:a, :b, :c]], :dataset=>proc{Tag.join(:albums_tags, [:tag_id]).join(:albums, [:album_id]).join(:albums_artists, [:album_id]).filter(:albums_artists__artist_id=>id)}
+    @c1.one_through_many :tag, [[:a, :b, :c]], :dataset=>proc{Tag.join(:albums_tags, [:tag_id]).join(:albums, [:album_id]).join(:albums_artists, [:album_id]).filter(Sequel[:albums_artists][:artist_id]=>id)}
     n = @c1.load(:id => 1234)
     n.tag_dataset.sql.must_equal 'SELECT tags.* FROM tags INNER JOIN albums_tags USING (tag_id) INNER JOIN albums USING (album_id) INNER JOIN albums_artists USING (album_id) WHERE (albums_artists.artist_id = 1234) LIMIT 1'
     n.tag.must_equal @c2.load(:id=>1)
@@ -1856,7 +1875,7 @@ describe "one_through_many eager loading methods" do
   end
 
   it "should respect the association's :select option" do
-    @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>:tags__name
+    @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>Sequel[:tags][:name]
     a = @c1.eager(:tag).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -2107,10 +2126,15 @@ describe "one_through_many eager loading methods" do
 
   it "should respect the association's :order" do
     @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :order=>[:blah1, :blah2]
-    @c1.order(:artists__blah2, :artists__blah3).eager_graph(:tag).sql.must_equal 'SELECT artists.id, tag.id AS tag_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags AS tag ON (tag.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3, tag.blah1, tag.blah2'
+    @c1.order(Sequel[:artists][:blah2], Sequel[:artists][:blah3]).eager_graph(:tag).sql.must_equal 'SELECT artists.id, tag.id AS tag_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags AS tag ON (tag.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3, tag.blah1, tag.blah2'
   end
 
   it "should only qualify unqualified symbols, identifiers, or ordered versions in association's :order" do
+    @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :order=>[Sequel.identifier(:blah__id), Sequel.identifier(:blah__id).desc, Sequel.desc(Sequel[:blah][:id]), Sequel[:blah][:id], :album_id, Sequel.desc(:album_id), 1, Sequel.lit('RANDOM()'), Sequel.qualify(:b, :a)]
+    @c1.order(Sequel[:artists][:blah2], Sequel[:artists][:blah3]).eager_graph(:tag).sql.must_equal 'SELECT artists.id, tag.id AS tag_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags AS tag ON (tag.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3, tag.blah__id, tag.blah__id DESC, blah.id DESC, blah.id, tag.album_id, tag.album_id DESC, 1, RANDOM(), b.a'
+  end
+
+  with_symbol_splitting "should not qualify qualified symbols in association's :order" do
     @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :order=>[Sequel.identifier(:blah__id), Sequel.identifier(:blah__id).desc, Sequel.desc(:blah__id), :blah__id, :album_id, Sequel.desc(:album_id), 1, Sequel.lit('RANDOM()'), Sequel.qualify(:b, :a)]
     @c1.order(:artists__blah2, :artists__blah3).eager_graph(:tag).sql.must_equal 'SELECT artists.id, tag.id AS tag_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags AS tag ON (tag.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3, tag.blah__id, tag.blah__id DESC, blah.id DESC, blah.id, tag.album_id, tag.album_id DESC, 1, RANDOM(), b.a'
   end

data/spec/extensions/nested_attributes_spec.rb

@@ -652,8 +652,12 @@ describe "NestedAttributes plugin" do
       "UPDATE tags SET name = 'T2' WHERE (id = 30)",
       "INSERT INTO tags (name) VALUES ('T3')",
       ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
-    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.must_raise(Sequel::MassAssignmentRestriction)
-    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.must_raise(Sequel::MassAssignmentRestriction)
+    al.set(:tags_attributes=>[{:id=>30, :name=>'T3', :number=>3}])
+    al.tags.first.name.must_equal 'T3'
+    al.tags.first.number.must_equal 10
+    al.set(:tags_attributes=>[{:name=>'T4', :number=>3}])
+    al.tags.last.name.must_equal 'T4'
+    al.tags.last.number.must_be_nil
   end
 
   it "should accept a proc for the :fields option that accepts the associated object and returns an array of fields" do
@@ -670,8 +674,12 @@ describe "NestedAttributes plugin" do
       "UPDATE tags SET name = 'T2' WHERE (id = 30)",
       "INSERT INTO tags (name) VALUES ('T3')",
       ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
-    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.must_raise(Sequel::MassAssignmentRestriction)
-    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.must_raise(Sequel::MassAssignmentRestriction)
+    al.set_nested_attributes(:tags, [{:id=>30, :name=>'T3', :number=>3}], :fields=>[:name])
+    al.tags.first.name.must_equal 'T3'
+    al.tags.first.number.must_equal 10
+    al.set_nested_attributes(:tags, [{:name=>'T4', :number=>3}], :fields=>[:name])
+    al.tags.last.name.must_equal 'T4'
+    al.tags.last.number.must_be_nil
   end
 
   it "should allow per-call options via the set_nested_attributes method" do
@@ -688,8 +696,12 @@ describe "NestedAttributes plugin" do
       "UPDATE tags SET name = 'T2' WHERE (id = 30)",
       "INSERT INTO tags (name) VALUES ('T3')",
       ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
-    proc{al.set_nested_attributes(:tags, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.must_raise(Sequel::MassAssignmentRestriction)
-    proc{al.set_nested_attributes(:tags, [{:name=>'T2', :number=>3}], :fields=>[:name])}.must_raise(Sequel::MassAssignmentRestriction)
+    al.set_nested_attributes(:tags, [{:id=>30, :name=>'T3', :number=>3}], :fields=>[:name])
+    al.tags.first.name.must_equal 'T3'
+    al.tags.first.number.must_equal 10
+    al.set_nested_attributes(:tags, [{:name=>'T4', :number=>3}], :fields=>[:name])
+    al.tags.last.name.must_equal 'T4'
+    al.tags.last.number.must_be_nil
   end
 
   it "should have set_nested_attributes method raise error if called with a bad association" do

data/spec/extensions/no_auto_literal_strings_spec.rb

@@ -38,7 +38,7 @@ describe "no_auto_literal_strings extension" do
                             "SELECT * FROM t WHERE (a) LIMIT 1"]
   end
   
-  it "should handle literal strings in arrays in filter methods" do
+  deprecated "should handle literal strings in arrays in filter methods" do
     @ds.where([Sequel.lit("a")]).sql.must_equal 'SELECT * FROM t WHERE (a)'
   end
 

data/spec/extensions/pg_enum_spec.rb

@@ -33,6 +33,11 @@ describe "pg_enum extension" do
   it "should support #create_enum method for adding a new enum" do
     @db.create_enum(:foo, [:a, :b, :c])
     @db.sqls.first.must_equal "CREATE TYPE foo AS ENUM ('a', 'b', 'c')"
+    @db.create_enum(Sequel[:sch][:foo], %w'a b c')
+    @db.sqls.first.must_equal "CREATE TYPE sch.foo AS ENUM ('a', 'b', 'c')"
+  end
+
+  with_symbol_splitting "should support #create_enum method for adding a new enum with qualified symbol" do
     @db.create_enum(:sch__foo, %w'a b c')
     @db.sqls.first.must_equal "CREATE TYPE sch.foo AS ENUM ('a', 'b', 'c')"
   end
@@ -40,12 +45,17 @@ describe "pg_enum extension" do
   it "should support #drop_enum method for dropping an enum" do
     @db.drop_enum(:foo)
     @db.sqls.first.must_equal "DROP TYPE foo"
-    @db.drop_enum(:sch__foo, :if_exists=>true)
+    @db.drop_enum(Sequel[:sch][:foo], :if_exists=>true)
     @db.sqls.first.must_equal "DROP TYPE IF EXISTS sch.foo"
     @db.drop_enum('foo', :cascade=>true)
     @db.sqls.first.must_equal "DROP TYPE foo CASCADE"
   end
 
+  with_symbol_splitting "should support #drop_enum method for dropping an enum with a splittable symbol" do
+    @db.drop_enum(:sch__foo, :if_exists=>true)
+    @db.sqls.first.must_equal "DROP TYPE IF EXISTS sch.foo"
+  end
+
   it "should support #add_enum_value method for adding value to an existing enum" do
     @db.add_enum_value(:foo, :a)
     @db.sqls.first.must_equal "ALTER TYPE foo ADD VALUE 'a'"
@@ -57,6 +67,11 @@ describe "pg_enum extension" do
   end
 
   it "should support :after option for #add_enum_value method for adding value after an existing enum value" do
+    @db.add_enum_value(Sequel[:sch][:foo], :a, :after=>:b)
+    @db.sqls.first.must_equal "ALTER TYPE sch.foo ADD VALUE 'a' AFTER 'b'"
+  end
+
+  with_symbol_splitting "should support :after option for #add_enum_value method for adding value after an existing enum value with splittable symbol" do
     @db.add_enum_value(:sch__foo, :a, :after=>:b)
     @db.sqls.first.must_equal "ALTER TYPE sch.foo ADD VALUE 'a' AFTER 'b'"
   end

data/spec/extensions/pg_interval_spec.rb

@@ -2,6 +2,10 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 begin
   require 'active_support/duration'
+  begin
+    require 'active_support/gem_version'
+  rescue LoadError
+  end
 rescue LoadError => exc
   skip_warn "pg_interval plugin: can't load active_support/duration (#{exc.class}: #{exc})"
 else
@@ -21,8 +25,13 @@ describe "pg_interval extension" do
   end
 
   it "should literalize ActiveSupport::Duration instances with repeated parts correctly" do
-    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1]])).must_equal "'3 seconds '::interval"
-    @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1], [:days, 1], [:days, 4]])).must_equal "'5 days 3 seconds '::interval"
+    if defined?(ActiveSupport::VERSION::STRING) && ActiveSupport::VERSION::STRING >= '5.1'
+      @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1]])).must_equal "'1 seconds '::interval"
+      @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1], [:days, 1], [:days, 4]])).must_equal "'4 days 1 seconds '::interval"
+    else
+      @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1]])).must_equal "'3 seconds '::interval"
+      @db.literal(ActiveSupport::Duration.new(0, [[:seconds, 2], [:seconds, 1], [:days, 1], [:days, 4]])).must_equal "'5 days 3 seconds '::interval"
+    end
   end
 
   it "should not affect literalization of custom objects" do

data/spec/extensions/pg_loose_count_spec.rb

@@ -12,6 +12,11 @@ describe "pg_loose_count extension" do
   end
 
   it "should support schema qualified tables" do
+    @db.loose_count(Sequel[:a][:b]).must_equal 1
+    @db.sqls.must_equal ["SELECT CAST(reltuples AS integer) AS v FROM pg_class WHERE (oid = CAST(CAST('a.b' AS regclass) AS oid)) LIMIT 1"]
+  end
+
+  with_symbol_splitting "should support schema qualified table symbols" do
     @db.loose_count(:a__b).must_equal 1
     @db.sqls.must_equal ["SELECT CAST(reltuples AS integer) AS v FROM pg_class WHERE (oid = CAST(CAST('a.b' AS regclass) AS oid)) LIMIT 1"]
   end

data/spec/extensions/pg_row_spec.rb

@@ -207,6 +207,31 @@ describe "pg_row extension" do
   end
 
   it "should allow registering row type parsers for schema qualify types" do
+    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
+    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    @db.register_row_type(Sequel[:foo][:bar])
+    @db.sqls.must_equal ["SELECT pg_type.oid, typrelid, typarray FROM pg_type INNER JOIN pg_namespace ON ((pg_namespace.oid = pg_type.typnamespace) AND (pg_namespace.nspname = 'foo')) WHERE ((typtype = 'c') AND (typname = 'bar')) LIMIT 1",
+      "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
+    p1 = @db.conversion_procs[1]
+    p1.columns.must_equal [:bar, :baz]
+    p1.column_oids.must_equal [4, 5]
+    p1.column_converters.must_equal [p4, p5]
+    p1.oid.must_equal 1
+
+    c = p1.converter
+    c.superclass.must_equal @m::HashRow
+    c.columns.must_equal [:bar, :baz]
+    c.db_type.must_equal Sequel[:foo][:bar]
+    p1.typecaster.must_equal c
+
+    p1.call('(1,b)').must_equal(:bar=>1, :baz=>'bb')
+    @db.typecast_value(:pg_row_foo__bar, %w'1 b').must_equal(:bar=>'1', :baz=>'b')
+    @db.typecast_value(:pg_row_foo__bar, :bar=>'1', :baz=>'b').must_equal(:bar=>'1', :baz=>'b')
+    @db.literal(p1.call('(1,b)')).must_equal "ROW(1, 'bb')::foo.bar"
+  end
+
+  with_symbol_splitting "should allow registering row type parsers for schema qualify type symbols" do
     @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
     @db.conversion_procs[5] = p5 = proc{|s| s * 2}
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]