sequel 4.48.0 → 4.49.0

data/spec/core/dataset_spec.rb

@@ -1895,6 +1895,126 @@ describe "Dataset#with_extend" do
   end
 end
 
+describe "Dataset#with_extend custom methods" do
+  before do
+    @ds = Sequel.mock[:items]
+  end
+  
+  it "should have dataset_module support a where method" do
+    @ds = @ds.with_extend{where :released, :released}
+    @ds.released.sql.must_equal 'SELECT * FROM items WHERE released'
+    @ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND released)'
+  end
+
+  it "should have dataset_module support a having method" do
+    @ds = @ds.with_extend{having(:released){released}}
+    @ds.released.sql.must_equal 'SELECT * FROM items HAVING released'
+    @ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE foo HAVING released'
+  end
+
+  it "should have dataset_module support an exclude method" do
+    @ds = @ds.with_extend{exclude :released, :released}
+    @ds.released.sql.must_equal 'SELECT * FROM items WHERE NOT released'
+    @ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND NOT released)'
+  end
+
+  it "should have dataset_module support an exclude_having method" do
+    @ds = @ds.with_extend{exclude_having :released, :released}
+    @ds.released.sql.must_equal 'SELECT * FROM items HAVING NOT released'
+    @ds.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE foo HAVING NOT released'
+  end
+
+  it "should have dataset_module support a distinct method" do
+    @ds = @ds.with_extend{def supports_distinct_on?; true end; distinct :foo, :baz}
+    @ds.foo.sql.must_equal 'SELECT DISTINCT ON (baz) * FROM items'
+    @ds.where(:bar).foo.sql.must_equal 'SELECT DISTINCT ON (baz) * FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a grep method" do
+    @ds = @ds.with_extend{grep :foo, :baz, 'quux%'}
+    @ds.foo.sql.must_equal 'SELECT * FROM items WHERE ((baz LIKE \'quux%\' ESCAPE \'\\\'))'
+    @ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE (bar AND ((baz LIKE \'quux%\' ESCAPE \'\\\')))'
+  end
+
+  it "should have dataset_module support a group method" do
+    @ds = @ds.with_extend{group :foo, :baz}
+    @ds.foo.sql.must_equal 'SELECT * FROM items GROUP BY baz'
+    @ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a group_and_count method" do
+    @ds = @ds.with_extend{group_and_count :foo, :baz}
+    @ds.foo.sql.must_equal 'SELECT baz, count(*) AS count FROM items GROUP BY baz'
+    @ds.where(:bar).foo.sql.must_equal 'SELECT baz, count(*) AS count FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a group_append method" do
+    @ds = @ds.with_extend{group_append :foo, :baz}
+    @ds.foo.sql.must_equal 'SELECT * FROM items GROUP BY baz'
+    @ds.group(:bar).foo.sql.must_equal 'SELECT * FROM items GROUP BY bar, baz'
+  end
+
+  it "should have dataset_module support a limit method" do
+    @ds = @ds.with_extend{limit :foo, 1}
+    @ds.foo.sql.must_equal 'SELECT * FROM items LIMIT 1'
+    @ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar LIMIT 1'
+  end
+
+  it "should have dataset_module support a offset method" do
+    @ds = @ds.with_extend{offset :foo, 1}
+    @ds.foo.sql.must_equal 'SELECT * FROM items OFFSET 1'
+    @ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar OFFSET 1'
+  end
+
+  it "should have dataset_module support a order method" do
+    @ds = @ds.with_extend{order(:foo){:baz}}
+    @ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    @ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar ORDER BY baz'
+  end
+
+  it "should have dataset_module support a order_append method" do
+    @ds = @ds.with_extend{order_append :foo, :baz}
+    @ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    @ds.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY bar, baz'
+  end
+
+  it "should have dataset_module support a order_prepend method" do
+    @ds = @ds.with_extend{order_prepend :foo, :baz}
+    @ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    @ds.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY baz, bar'
+  end
+
+  it "should have dataset_module support a select method" do
+    @ds = @ds.with_extend{select :foo, :baz}
+    @ds.foo.sql.must_equal 'SELECT baz FROM items'
+    @ds.where(:bar).foo.sql.must_equal 'SELECT baz FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_all method" do
+    @ds = @ds.with_extend{select_all :foo, :baz}
+    @ds.foo.sql.must_equal 'SELECT baz.* FROM items'
+    @ds.where(:bar).foo.sql.must_equal 'SELECT baz.* FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_append method" do
+    @ds = @ds.with_extend{select_append :foo, :baz}
+    @ds.foo.sql.must_equal 'SELECT *, baz FROM items'
+    @ds.where(:bar).foo.sql.must_equal 'SELECT *, baz FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_group method" do
+    @ds = @ds.with_extend{select_group :foo, :baz}
+    @ds.foo.sql.must_equal 'SELECT baz FROM items GROUP BY baz'
+    @ds.where(:bar).foo.sql.must_equal 'SELECT baz FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a server method" do
+    @ds = @ds.with_extend{server :foo, :baz}
+    @ds.foo.opts[:server].must_equal :baz
+    @ds.where(:bar).foo.opts[:server].must_equal :baz
+  end
+end
+
 describe "Dataset#with_row_proc" do
   it "should returned clone dataset with the given row_proc" do
     d = Sequel.mock.dataset
@@ -5533,3 +5653,56 @@ describe "Dataset#output_identifier" do
     meth.call('A').must_equal :a
   end
 end
+
+describe "Dataset#where_all"  do
+  before do
+    @ds = Sequel.mock(:fetch=>{:id=>1})[:items].freeze
+  end
+
+  it "should filter dataset with condition, and return related rows" do
+    5.times do
+      @ds.where_all(:id=>1).must_equal [{:id=>1}]
+      @ds.db.sqls.must_equal ['SELECT * FROM items WHERE (id = 1)']
+    end
+  end
+
+  it "should yield each row to the given block" do
+    5.times do
+      a = []
+      @ds.where_all(:id=>1){|r| a << r}.must_equal [{:id=>1}]
+      a.must_equal [{:id=>1}]
+      @ds.db.sqls.must_equal ['SELECT * FROM items WHERE (id = 1)']
+    end
+  end
+end
+
+describe "Dataset#where_each"  do
+  before do
+    @ds = Sequel.mock(:fetch=>{:id=>1})[:items].freeze
+  end
+
+  it "should yield each row to the given block" do
+    5.times do
+      a = []
+      @ds.where_each(:id=>1){|r| a << r}
+      a.must_equal [{:id=>1}]
+      @ds.db.sqls.must_equal ['SELECT * FROM items WHERE (id = 1)']
+    end
+  end
+end
+
+describe "Dataset#where_single_value"  do
+  before do
+    @ds = Sequel.mock(:fetch=>{:id=>1})[:items].with_extend do
+      select :only_id, :id
+    end.freeze
+  end
+
+  it "should return single value" do
+    5.times do
+      a = []
+      @ds.only_id.where_single_value(:id=>1).must_equal 1
+      @ds.db.sqls.must_equal ['SELECT id FROM items WHERE (id = 1) LIMIT 1']
+    end
+  end
+end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -585,7 +585,7 @@ describe "class_table_inheritance plugin with :alias option" do
     Executive.cti_models.first.must_equal Employee
   end
 
-  it "#cti_columns should be a mapping of table names to columns" do
+  deprecated "#cti_columns should be a mapping of table names to columns" do
     Executive.cti_columns.must_equal(:employees=>[:id, :name, :kind], :managers=>[:id, :num_staff], :executives=>[:id, :num_managers])
   end
 
@@ -1080,15 +1080,13 @@ describe "class_table_inheritance plugin with :alias option" do
     class ::Staff < Employee
       many_to_one :manager
     end 
+    class ::Intern < Employee
+    end 
     @ds = Employee.dataset
     @db.sqls
   end
   after do
-    Object.send(:remove_const, :Ceo)
-    Object.send(:remove_const, :Executive)
-    Object.send(:remove_const, :Manager)
-    Object.send(:remove_const, :Staff)
-    Object.send(:remove_const, :Employee)
+    [:Intern, :Ceo, :Executive, :Manager, :Staff, :Employee].each{|s| Object.send(:remove_const, s)}
   end
 
   it "should freeze CTI information when freezing model class" do
@@ -1119,7 +1117,7 @@ describe "class_table_inheritance plugin with :alias option" do
     Executive.cti_models.first.must_equal Employee
   end
 
-  it "#cti_columns should be a mapping of table names to columns" do
+  deprecated "#cti_columns should be a mapping of table names to columns" do
     Executive.cti_columns.must_equal(:employees=>[:id, :name, :kind], :managers=>[:id, :num_staff], :executives=>[:id, :num_managers])
   end
 
@@ -1128,6 +1126,7 @@ describe "class_table_inheritance plugin with :alias option" do
     Executive.simple_table.must_be_nil
     Ceo.simple_table.must_be_nil
     Staff.simple_table.must_be_nil
+    Intern.simple_table.must_be_nil
   end
   
   it "should have working row_proc if using set_dataset in subclass to remove columns" do
@@ -1142,10 +1141,11 @@ describe "class_table_inheritance plugin with :alias option" do
     Executive.dataset.sql.must_equal 'SELECT * FROM (SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id)) AS employees'
     Ceo.dataset.sql.must_equal 'SELECT * FROM (SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (employees.kind IN (\'Ceo\'))) AS employees'
     Staff.dataset.sql.must_equal 'SELECT * FROM (SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id)) AS employees'
+    Intern.dataset.sql.must_equal 'SELECT * FROM employees WHERE (employees.kind IN (\'Intern\'))'
   end
   
   it "should return rows with the correct class based on the polymorphic_key value" do
-    @ds.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}]).all.collect{|x| x.class}.must_equal [Employee, Manager, Executive, Ceo, Staff]
+    @ds.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}, {:kind=>'Intern'}]).all.collect{|x| x.class}.must_equal [Employee, Manager, Executive, Ceo, Staff, Intern]
   end 
   
   it "should return rows with the correct class based on the polymorphic_key value for subclasses" do
@@ -1165,7 +1165,7 @@ describe "class_table_inheritance plugin with :alias option" do
   
   it "should return rows with the current class if cti_key is nil" do
     Employee.plugin(:class_table_inheritance, :alias=>:employees)
-    Employee.dataset.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}]).all.map{|x| x.class}.must_equal [Employee, Employee, Employee, Employee, Employee]
+    Employee.dataset.with_fetch([{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Ceo'}, {:kind=>'Staff'}, {:kind=>'Intern'}]).all.map{|x| x.class}.must_equal [Employee, Employee, Employee, Employee, Employee, Employee]
   end
   
   it "should return rows with the current class if cti_key is nil in subclasses" do
@@ -1178,15 +1178,17 @@ describe "class_table_inheritance plugin with :alias option" do
   end
   
   it "should handle a model map with integer values" do
-    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive, 3=>:Ceo}, :alias=>:employees)
+    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive, 3=>:Ceo, 4=>:Intern}, :alias=>:employees)
+    Object.send(:remove_const, :Intern)
     Object.send(:remove_const, :Ceo)
     Object.send(:remove_const, :Executive)
     Object.send(:remove_const, :Manager)
+    class ::Intern < Employee; end 
     class ::Manager < Employee; end 
     class ::Executive < Manager; end 
     class ::Ceo < Executive; end 
-    Employee.dataset = Employee.dataset.with_fetch([{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}])
-    Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Manager, Executive, Ceo]
+    Employee.dataset = Employee.dataset.with_fetch([{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}, {:kind=>4}])
+    Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Manager, Executive, Ceo, Intern]
     Manager.dataset = Manager.dataset.with_fetch([{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}, {:kind=>3}])
     Manager.all.collect{|x| x.class}.must_equal [Manager, Employee, Manager, Executive, Ceo]
   end
@@ -1204,6 +1206,11 @@ describe "class_table_inheritance plugin with :alias option" do
     @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Employee')"]
   end
   
+  it "should sets the model class name for the key when creating new class records for subclass without separate table" do
+    Intern.create
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Intern')"]
+  end
+  
   it "should sets the model class name for the key when creating new subclass records" do
     Ceo.create
     @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Ceo')",
@@ -1278,10 +1285,11 @@ describe "class_table_inheritance plugin with :alias option" do
     Manager.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer})
     Executive.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer}, :num_managers=>{:type=>:integer})
     Staff.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :manager_id=>{:type=>:integer})
+    Intern.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string})
   end
 
   it "should use the correct primary key (which should have the same name in all subclasses)" do
-    [Employee, Manager, Executive, Ceo, Staff].each{|c| c.primary_key.must_equal :id}
+    [Employee, Manager, Executive, Ceo, Staff, Intern].each{|c| c.primary_key.must_equal :id}
   end
 
   it "should have table_name return the table name of the most specific table" do
@@ -1290,20 +1298,43 @@ describe "class_table_inheritance plugin with :alias option" do
     Executive.table_name.must_equal :employees
     Ceo.table_name.must_equal :employees
     Staff.table_name.must_equal :employees
+    Intern.table_name.must_equal :employees
   end
 
   it "should delete the correct rows from all tables when deleting" do
+    Employee.load(:id=>1).delete
+    @db.sqls.must_equal ["DELETE FROM employees WHERE (id = 1)"]
+
+    Intern.load(:id=>1).delete
+    @db.sqls.must_equal ["DELETE FROM employees WHERE (id = 1)"]
+
     Ceo.load(:id=>1).delete
     @db.sqls.must_equal ["DELETE FROM executives WHERE (id = 1)", "DELETE FROM managers WHERE (id = 1)", "DELETE FROM employees WHERE (id = 1)"]
   end
 
   it "should not allow deletion of frozen object" do
-    o = Ceo.load(:id=>1)
-    o.freeze
-    proc{o.delete}.must_raise(Sequel::Error)
-    @db.sqls.must_equal []
+    [Ceo, Executive, Employee, Manager, Intern].each do |c|
+      o = c.load(:id=>1)
+      o.freeze
+      proc{o.delete}.must_raise(Sequel::Error)
+      @db.sqls.must_equal []
+    end
   end
 
+  it "should insert the correct rows into all tables when inserting into parent class" do
+    Employee.create(:name=>'E')
+    sqls = @db.sqls
+    sqls.length.must_equal 1
+    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Employee)', '(E|Employee)'\)/)
+  end
+    
+  it "should insert the correct rows into all tables when inserting into subclass without separate table" do
+    Intern.create(:name=>'E')
+    sqls = @db.sqls
+    sqls.length.must_equal 1
+    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Intern)', '(E|Intern)'\)/)
+  end
+    
   it "should insert the correct rows into all tables when inserting" do
     Ceo.create(:num_managers=>3, :num_staff=>2, :name=>'E')
     sqls = @db.sqls
@@ -1342,6 +1373,16 @@ describe "class_table_inheritance plugin with :alias option" do
     sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/)
   end
 
+  it "should update the correct rows in all tables when updating parent class" do
+    Employee.load(:id=>2).update(:name=>'E')
+    @db.sqls.must_equal ["UPDATE employees SET name = 'E' WHERE (id = 2)"]
+  end
+
+  it "should update the correct rows in all tables when updating subclass without separate table" do
+    Intern.load(:id=>2).update(:name=>'E')
+    @db.sqls.must_equal ["UPDATE employees SET name = 'E' WHERE (id = 2)"]
+  end
+
   it "should update the correct rows in all tables when updating" do
     Ceo.load(:id=>2).update(:num_managers=>3, :num_staff=>2, :name=>'E')
     @db.sqls.must_equal ["UPDATE employees SET name = 'E' WHERE (id = 2)", "UPDATE managers SET num_staff = 2 WHERE (id = 2)", "UPDATE executives SET num_managers = 3 WHERE (id = 2)"]

data/spec/extensions/composition_spec.rb

@@ -44,6 +44,19 @@ describe "Composition plugin" do
     o.valid?.must_equal true
   end
 
+  it "should have decomposer work with column_conflicts plugin" do
+    @c.plugin :column_conflicts
+    @c.set_column_conflict! :year
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    o = @c.new
+    def o.validate
+      [:year, :month, :day].each{|c| errors.add(c, "not present") unless send(c)}
+    end
+    o.valid?.must_equal false
+    o.date = Date.new(1, 2, 3)
+    o.valid?.must_equal true
+  end
+
   it "should set column values even when not validating" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     @c.load({}).set(:date=>Date.new(4, 8, 12)).save(:validate=>false)

data/spec/extensions/dataset_associations_spec.rb

@@ -13,14 +13,17 @@ describe "Sequel::Plugins::DatasetAssociations" do
     @Artist = Class.new(@Base)
     @Album = Class.new(@Base)
     @Tag = Class.new(@Base)
+    @Track = Class.new(@Base)
 
     def @Artist.name; 'Artist' end
     def @Album.name; 'Album' end
     def @Tag.name; 'Tag' end
+    def @Track.name; 'Track' end
 
     @Artist.dataset = @db[:artists]
     @Album.dataset = @db[:albums]
     @Tag.dataset = @db[:tags]
+    @Track.dataset = @db[:tracks]
 
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
@@ -28,6 +31,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
 
     @Album.plugin :many_through_many
     @Artist.plugin :many_through_many
+    @Track.plugin :many_through_many
     @Artist.plugin :pg_array_associations
     @Tag.plugin :pg_array_associations
     @Artist.one_to_many :albums, :class=>@Album
@@ -41,6 +45,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
     @Tag.many_to_pg_array :artists, :class=>@Artist
     @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
     @Artist.one_through_many :otag, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+    @Track.many_through_many :artist_tracks, [[:albums, :id, :artist_id], [:albums, :artist_id, :id]], :class=>@Track, :left_primary_key=>:album_id, :right_primary_key=>:album_id
   end
 
   it "should work for many_to_one associations" do
@@ -85,6 +90,13 @@ describe "Sequel::Plugins::DatasetAssociations" do
     ds.sql.must_equal "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
   end
 
+  it "should work for self referential many_through_many associations" do
+    ds = @Track.artist_tracks
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Track
+    ds.sql.must_equal "SELECT tracks.* FROM tracks WHERE (tracks.album_id IN (SELECT albums_0.id FROM tracks INNER JOIN albums ON (albums.id = tracks.album_id) INNER JOIN albums AS albums_0 ON (albums_0.artist_id = albums.artist_id) INNER JOIN tracks AS tracks_0 ON (tracks_0.album_id = albums_0.id) WHERE (albums.id IN (SELECT tracks.album_id FROM tracks))))"
+  end
+
   it "should work for many_through_many associations with a single join table" do
     ds = @Album.mthm_tags
     ds.must_be_kind_of(Sequel::Dataset)

data/spec/extensions/many_through_many_spec.rb

@@ -59,10 +59,10 @@ describe Sequel::Model, "many_through_many" do
     DB.sqls.must_equal []
   end
 
-  it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup" do
+  it "should handle a :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]], :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))"]
@@ -1231,10 +1231,10 @@ describe Sequel::Model, "one_through_many" do
     DB.sqls.must_equal []
   end
 
-  it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup" do
+  it "should handle a :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]], :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))"]