sequel 4.46.0 → 4.49.0

data/spec/core/dataset_spec.rb

@@ -765,11 +765,11 @@ describe "Dataset#and" do
     @d1 = @dataset.where(:x => 1)
   end
   
-  it "should add a WHERE filter if none exists" do
+  deprecated "should add a WHERE filter if none exists" do
     @dataset.and(:a => 1).sql.must_equal 'SELECT * FROM test WHERE (a = 1)'
   end
   
-  it "should add an expression to the where clause" do
+  deprecated "should add an expression to the where clause" do
     @d1.and(:y => 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y = 2))'
   end
   
@@ -777,19 +777,19 @@ describe "Dataset#and" do
     @d1.and('y > ?', 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
   end
 
-  it "should accept placeholder literal string filters" do
+  deprecated "should accept placeholder literal string filters" do
     @d1.and(Sequel.lit('y > ?', 2)).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
   end
 
-  it "should accept expression filters" do
+  deprecated "should accept expression filters" do
     @d1.and(Sequel.expr(:yy) > 3).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
   end
       
-  it "should accept blocks passed to filter" do
+  deprecated "should accept blocks passed to filter" do
     @d1.and{yy > 3}.sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
   end
   
-  it "should correctly add parens to give predictable results" do
+  deprecated "should correctly add parens to give predictable results" do
     @d1.or(:y => 2).and(:z => 3).sql.must_equal 'SELECT * FROM test WHERE (((x = 1) OR (y = 2)) AND (z = 3))'
     @d1.and(:y => 2).or(:z => 3).sql.must_equal 'SELECT * FROM test WHERE (((x = 1) AND (y = 2)) OR (z = 3))'
   end
@@ -845,19 +845,19 @@ describe "Dataset#exclude_where" do
     @dataset = Sequel.mock.dataset.from(:test)
   end
 
-  it "should correctly negate the expression and add it to the where clause" do
+  deprecated "should correctly negate the expression and add it to the where clause" do
     @dataset.exclude_where(:region=>'Asia').sql.must_equal "SELECT * FROM test WHERE (region != 'Asia')"
     @dataset.exclude_where(:region=>'Asia').exclude_where(:region=>'NA').sql.must_equal "SELECT * FROM test WHERE ((region != 'Asia') AND (region != 'NA'))"
   end
 
-  it "should affect the where clause even if having clause is already used" do
+  deprecated "should affect the where clause even if having clause is already used" do
     @dataset.group_and_count(:name).having{count > 2}.exclude_where(:region=>'Asia').sql.
       must_equal "SELECT name, count(*) AS count FROM test WHERE (region != 'Asia') GROUP BY name HAVING (count > 2)"
   end
 end
 
 describe "Dataset#exclude_having" do
-  it "should correctly negate the expression and add it to the having clause" do
+  deprecated "should correctly negate the expression and add it to the having clause" do
     Sequel.mock.dataset.from(:test).exclude_having{count > 2}.exclude_having{count < 0}.sql.must_equal "SELECT * FROM test HAVING ((count <= 2) AND (count >= 0))"
   end
 end
@@ -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
@@ -1976,46 +2096,51 @@ describe "Dataset#map" do
   end
 end
 
-describe "Dataset#to_hash" do
+describe "Dataset#as_hash" do
   before do
     @d = Sequel.mock(:fetch=>[{:a => 1, :b => 2}, {:a => 3, :b => 4}, {:a => 5, :b => 6}])[:items]
   end
   
   it "should provide a hash with the first column as key and the second as value" do
+    @d.as_hash(:a, :b).must_equal(1 => 2, 3 => 4, 5 => 6)
+    @d.as_hash(:b, :a).must_equal(2 => 1, 4 => 3, 6 => 5)
+  end
+  
+  it "should be aliased as #to_hash" do
     @d.to_hash(:a, :b).must_equal(1 => 2, 3 => 4, 5 => 6)
     @d.to_hash(:b, :a).must_equal(2 => 1, 4 => 3, 6 => 5)
   end
   
   it "should provide a hash with the first column as key and the entire hash as value if the value column is blank or nil" do
-    @d.to_hash(:a).must_equal(1 => {:a => 1, :b => 2}, 3 => {:a => 3, :b => 4}, 5 => {:a => 5, :b => 6})
-    @d.to_hash(:b).must_equal(2 => {:a => 1, :b => 2}, 4 => {:a => 3, :b => 4}, 6 => {:a => 5, :b => 6})
+    @d.as_hash(:a).must_equal(1 => {:a => 1, :b => 2}, 3 => {:a => 3, :b => 4}, 5 => {:a => 5, :b => 6})
+    @d.as_hash(:b).must_equal(2 => {:a => 1, :b => 2}, 4 => {:a => 3, :b => 4}, 6 => {:a => 5, :b => 6})
   end
 
   it "should accept an optional :hash parameter into which entries can be merged" do
-    @d.to_hash(:a, :b, :hash => (tmp = {})).must_be_same_as(tmp)
+    @d.as_hash(:a, :b, :hash => (tmp = {})).must_be_same_as(tmp)
   end
 
   it "should support using an array of columns as either the key or the value" do
-    @d.to_hash([:a, :b], :b).must_equal([1, 2] => 2, [3, 4] => 4, [5, 6] => 6)
-    @d.to_hash(:b, [:a, :b]).must_equal(2 => [1, 2], 4 => [3, 4], 6 => [5, 6])
-    @d.to_hash([:b, :a], [:a, :b]).must_equal([2, 1] => [1, 2], [4, 3] => [3, 4], [6, 5] => [5, 6])
-    @d.to_hash([:a, :b]).must_equal([1, 2] => {:a => 1, :b => 2}, [3, 4] => {:a => 3, :b => 4}, [5, 6] => {:a => 5, :b => 6})
+    @d.as_hash([:a, :b], :b).must_equal([1, 2] => 2, [3, 4] => 4, [5, 6] => 6)
+    @d.as_hash(:b, [:a, :b]).must_equal(2 => [1, 2], 4 => [3, 4], 6 => [5, 6])
+    @d.as_hash([:b, :a], [:a, :b]).must_equal([2, 1] => [1, 2], [4, 3] => [3, 4], [6, 5] => [5, 6])
+    @d.as_hash([:a, :b]).must_equal([1, 2] => {:a => 1, :b => 2}, [3, 4] => {:a => 3, :b => 4}, [5, 6] => {:a => 5, :b => 6})
   end
 
   it "should not call the row_proc if two arguments are given" do
     @d = @d.with_row_proc(proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h})
-    @d.to_hash(:a, :b).must_equal(1 => 2, 3 => 4, 5 => 6)
-    @d.to_hash(:b, :a).must_equal(2 => 1, 4 => 3, 6 => 5)
-    @d.to_hash([:a, :b], :b).must_equal([1, 2] => 2, [3, 4] => 4, [5, 6] => 6)
-    @d.to_hash(:b, [:a, :b]).must_equal(2 => [1, 2], 4 => [3, 4], 6 => [5, 6])
-    @d.to_hash([:b, :a], [:a, :b]).must_equal([2, 1] => [1, 2], [4, 3] => [3, 4], [6, 5] => [5, 6])
+    @d.as_hash(:a, :b).must_equal(1 => 2, 3 => 4, 5 => 6)
+    @d.as_hash(:b, :a).must_equal(2 => 1, 4 => 3, 6 => 5)
+    @d.as_hash([:a, :b], :b).must_equal([1, 2] => 2, [3, 4] => 4, [5, 6] => 6)
+    @d.as_hash(:b, [:a, :b]).must_equal(2 => [1, 2], 4 => [3, 4], 6 => [5, 6])
+    @d.as_hash([:b, :a], [:a, :b]).must_equal([2, 1] => [1, 2], [4, 3] => [3, 4], [6, 5] => [5, 6])
   end
 
   it "should call the row_proc if only a single argument is given" do
     @d = @d.with_row_proc(proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h})
-    @d.to_hash(:a).must_equal(2 => {:a => 2, :b => 4}, 6 => {:a => 6, :b => 8}, 10 => {:a => 10, :b => 12})
-    @d.to_hash(:b).must_equal(4 => {:a => 2, :b => 4}, 8 => {:a => 6, :b => 8}, 12 => {:a => 10, :b => 12})
-    @d.to_hash([:a, :b]).must_equal([2, 4] => {:a => 2, :b => 4}, [6, 8] => {:a => 6, :b => 8}, [10, 12] => {:a => 10, :b => 12})
+    @d.as_hash(:a).must_equal(2 => {:a => 2, :b => 4}, 6 => {:a => 6, :b => 8}, 10 => {:a => 10, :b => 12})
+    @d.as_hash(:b).must_equal(4 => {:a => 2, :b => 4}, 8 => {:a => 6, :b => 8}, 12 => {:a => 10, :b => 12})
+    @d.as_hash([:a, :b]).must_equal([2, 4] => {:a => 2, :b => 4}, [6, 8] => {:a => 6, :b => 8}, [10, 12] => {:a => 10, :b => 12})
   end
 
   it "should handle a single composite key when using a row_proc" do
@@ -2026,7 +2151,7 @@ describe "Dataset#to_hash" do
       def h; @h; end
       def ==(o) @h == o.h; end
     end
-    @d.with_row_proc(c).to_hash([:a, :b]).must_equal([1, 2] => c.call(:a => 1, :b => 2), [3, 4] => c.call(:a => 3, :b => 4), [5, 6] => c.call(:a => 5, :b => 6))
+    @d.with_row_proc(c).as_hash([:a, :b]).must_equal([1, 2] => c.call(:a => 1, :b => 2), [3, 4] => c.call(:a => 3, :b => 4), [5, 6] => c.call(:a => 5, :b => 6))
   end
 end
 
@@ -2755,7 +2880,7 @@ describe "Dataset#range" do
     @ds = @db[:test].freeze
   end
   
-  it "should generate a correct SQL statement" do
+  deprecated "should generate a correct SQL statement" do
     5.times do
       @ds.range(:stamp)
       @db.sqls.must_equal ["SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test LIMIT 1"]
@@ -2765,18 +2890,18 @@ describe "Dataset#range" do
     @db.sqls.must_equal ["SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test WHERE (price > 100) LIMIT 1"]
   end
   
-  it "should return a range object" do
+  deprecated "should return a range object" do
     5.times do
       @ds.range(:tryme).must_equal(1..10)
     end
   end
   
-  it "should use a subselect for the same conditions as count" do
+  deprecated "should use a subselect for the same conditions as count" do
     @ds.order(:stamp).limit(5).range(:stamp).must_equal(1..10)
     @db.sqls.must_equal ['SELECT min(stamp) AS v1, max(stamp) AS v2 FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1']
   end
   
-  it "should accept virtual row blocks" do
+  deprecated "should accept virtual row blocks" do
     5.times do
       @ds.range{a(b)}
       @db.sqls.must_equal ["SELECT min(a(b)) AS v1, max(a(b)) AS v2 FROM test LIMIT 1"]
@@ -2790,7 +2915,7 @@ describe "Dataset#interval" do
     @ds = @db[:test].freeze
   end
   
-  it "should generate the correct SQL statement" do
+  deprecated "should generate the correct SQL statement" do
     5.times do
       @ds.interval(:stamp)
       @db.sqls.must_equal ["SELECT (max(stamp) - min(stamp)) AS interval FROM test LIMIT 1"]
@@ -2800,7 +2925,7 @@ describe "Dataset#interval" do
     @db.sqls.must_equal ["SELECT (max(stamp) - min(stamp)) AS interval FROM test WHERE (price > 100) LIMIT 1"]
   end
   
-  it "should use a subselect for the same conditions as count" do
+  deprecated "should use a subselect for the same conditions as count" do
     ds = @ds.order(:stamp).limit(5)
     5.times do
       ds.interval(:stamp).must_equal 1234
@@ -2808,7 +2933,7 @@ describe "Dataset#interval" do
     end
   end
 
-  it "should accept virtual row blocks" do
+  deprecated "should accept virtual row blocks" do
     5.times do
       @ds.interval{a(b)}
       @db.sqls.must_equal ["SELECT (max(a(b)) - min(a(b))) AS interval FROM test LIMIT 1"]
@@ -3241,7 +3366,7 @@ describe "Dataset#get" do
   end
 end
 
-describe "Dataset#set_row_proc" do
+describe "Dataset#with_row_proc" do
   before do
     @db = Sequel.mock(:fetch=>[{:a=>1}, {:a=>2}])
     @dataset = @db[:items].with_row_proc(proc{|h| h[:der] = h[:a] + 2; h})
@@ -3911,6 +4036,7 @@ describe "Dataset prepared statements and bound variables " do
     @ds.filter(:num=>:$n).bind({:n=>1}.freeze).call(:each)
     @ds.filter(:num=>:$n).call(:select, :n=>1)
     @ds.filter(:num=>:$n).call([:map, :a], :n=>1)
+    @ds.filter(:num=>:$n).call([:as_hash, :a, :b], :n=>1)
     @ds.filter(:num=>:$n).call([:to_hash, :a, :b], :n=>1)
     @ds.filter(:num=>:$n).call([:to_hash_groups, :a, :b], :n=>1)
     @ds.filter(:num=>:$n).call(:first, :n=>1)
@@ -3925,6 +4051,7 @@ describe "Dataset prepared statements and bound variables " do
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1) LIMIT 1',
       'DELETE FROM items WHERE (num = 1)',
       'UPDATE items SET num = 2 WHERE (num = 1)',
@@ -3938,6 +4065,7 @@ describe "Dataset prepared statements and bound variables " do
     pss << @ds.filter(:num=>:$n).prepare(:each, :en)
     pss << @ds.filter(:num=>:$n).prepare(:select, :sn)
     pss << @ds.filter(:num=>:$n).prepare([:map, :a], :sm)
+    pss << @ds.filter(:num=>:$n).prepare([:as_hash, :a, :b], :ah)
     pss << @ds.filter(:num=>:$n).prepare([:to_hash, :a, :b], :sh)
     pss << @ds.filter(:num=>:$n).prepare([:to_hash_groups, :a, :b], :shg)
     pss << @ds.filter(:num=>:$n).prepare(:first, :fn)
@@ -3945,11 +4073,12 @@ describe "Dataset prepared statements and bound variables " do
     pss << @ds.filter(:num=>:$n).prepare(:update, :un, :num=>:$n2)
     pss << @ds.prepare(:insert, :in, :num=>:$n)
     pss << @ds.prepare(:insert_select, :ins, :num=>:$n)
-    @db.prepared_statements.keys.sort_by{|k| k.to_s}.must_equal [:dn, :en, :fn, :in, :ins, :sh, :shg, :sm, :sn, :un]
-    [:en, :sn, :sm, :sh, :shg, :fn, :dn, :un, :in, :ins].each_with_index{|x, i| @db.prepared_statements[x].must_equal pss[i]}
+    @db.prepared_statements.keys.sort_by{|k| k.to_s}.must_equal [:ah, :dn, :en, :fn, :in, :ins, :sh, :shg, :sm, :sn, :un]
+    [:en, :sn, :sm, :ah, :sh, :shg, :fn, :dn, :un, :in, :ins].each_with_index{|x, i| @db.prepared_statements[x].must_equal pss[i]}
     @db.call(:en, :n=>1){}
     @db.call(:sn, :n=>1)
     @db.call(:sm, :n=>1)
+    @db.call(:ah, :n=>1)
     @db.call(:sh, :n=>1)
     @db.call(:shg, :n=>1)
     @db.call(:fn, :n=>1)
@@ -3963,6 +4092,7 @@ describe "Dataset prepared statements and bound variables " do
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1) LIMIT 1',
       'DELETE FROM items WHERE (num = 1)',
       'UPDATE items SET num = 2 WHERE (num = 1)',
@@ -5523,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/core/schema_spec.rb

@@ -5,6 +5,11 @@ describe "DB#create_table" do
     @db = Sequel.mock
   end
   
+  deprecated "should support an CreateTableGenerator as second argument" do
+    @db.create_table(:cats, Sequel::Schema::CreateTableGenerator.new(@db){})
+    @db.sqls.must_equal ['CREATE TABLE cats ()']
+  end
+  
   it "should accept the table name" do
     @db.create_table(:cats) {}
     @db.sqls.must_equal ['CREATE TABLE cats ()']
@@ -516,6 +521,12 @@ describe "DB#create_table" do
     @db.sqls.must_equal ['CREATE TABLE cats (id integer)', 'CREATE INDEX cats_id_index ON cats (id)']
   end
 
+  it "should use savepoints around index creation if running inside a transaction if :ignore_index_errors option is used" do
+    meta_def(@db, :execute_ddl){|*a| super(*a); raise Sequel::DatabaseError if /blah/.match(a.first)}
+    @db.transaction{@db.create_table(:cats, :ignore_index_errors=>true){Integer :id; index :blah; index :id}}
+    @db.sqls.must_equal ["BEGIN", "CREATE TABLE cats (id integer)", "SAVEPOINT autopoint_1", "CREATE INDEX cats_blah_index ON cats (blah)", "ROLLBACK TO SAVEPOINT autopoint_1", "SAVEPOINT autopoint_1", "CREATE INDEX cats_id_index ON cats (id)", "RELEASE SAVEPOINT autopoint_1", "COMMIT"]
+  end
+
   it "should accept multiple index definitions" do
     @db.create_table(:cats) do
       integer :id
@@ -1007,6 +1018,11 @@ describe "DB#alter_table" do
     @db = Sequel.mock
   end
   
+  deprecated "should support an AlterTableGenerator as second argument" do
+    @db.alter_table(:cats, Sequel::Schema::AlterTableGenerator.new(@db){set_column_allow_null :score, false})
+    @db.sqls.must_equal ["ALTER TABLE cats ALTER COLUMN score SET NOT NULL"]
+  end
+  
   it "should allow adding not null constraint via set_column_allow_null with false argument" do
     @db.alter_table(:cats) do
       set_column_allow_null :score, false

data/spec/core/spec_helper.rb

@@ -19,6 +19,7 @@ require 'minitest/shared_description'
 require "#{File.dirname(File.dirname(__FILE__))}/deprecation_helper.rb"
 
 class Minitest::HooksSpec
+  # SEQUEL5: Replace with define_singleton_method
   def meta_def(obj, name, &block)
     (class << obj; self end).send(:define_method, name, &block)
   end

data/spec/core_extensions_spec.rb

@@ -316,13 +316,17 @@ describe "Array#sql_value_list and #sql_array" do
   it "should treat the array as an SQL value list instead of conditions when used as a placeholder value" do
     @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]])).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x = 1) AND (y = 2)))'
     @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_value_list)).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
-    @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_array)).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    deprecated do
+      @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_array)).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    end
   end
 
   it "should be no difference when used as a hash value" do
     @d.filter([:a, :b]=>[[:x, 1], [:y, 2]]).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
     @d.filter([:a, :b]=>[[:x, 1], [:y, 2]].sql_value_list).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
-    @d.filter([:a, :b]=>[[:x, 1], [:y, 2]].sql_array).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    deprecated do
+      @d.filter([:a, :b]=>[[:x, 1], [:y, 2]].sql_array).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    end
   end
 end
 

data/spec/extensions/active_model_spec.rb

@@ -59,7 +59,7 @@ describe "ActiveModel plugin" do
     @c.freeze
     @o.id2 = 2
     @o.to_param.must_equal '2-1'
-    @o.meta_def(:to_param_joiner){'|'}
+    def @o.to_param_joiner; '|' end
     @o.to_param.must_equal '2|1'
     @o.destroy
     @o.to_param.must_be_nil

data/spec/extensions/arbitrary_servers_spec.rb

@@ -33,7 +33,7 @@ describe "arbtirary servers" do
 
   it "should disconnect when connection is finished" do
     x, x1 = nil, nil
-    @db.meta_def(:disconnect_connection){|c| x = c}
+    meta_def(@db, :disconnect_connection){|c| x = c}
     @db.synchronize(:host=>'host1', :database=>'db1') do |c|
       x1 = c
       @db.synchronize(:host=>'host1', :database=>'db1') do |c2|

data/spec/extensions/association_pks_spec.rb

@@ -8,7 +8,8 @@ describe "Sequel::Plugins::AssociationPks" do
         {:id=>$1.to_i}
       when "SELECT id FROM albums WHERE (albums.artist_id = 1)"
         [{:id=>1}, {:id=>2}, {:id=>3}]
-      when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/
+      when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/,
+           /SELECT tags.id FROM tags INNER JOIN albums_tags ON \(albums_tags.tag_id = tags.id\) WHERE \(albums_tags.album_id = (\d)\)/
         a = []
         a << {:tag_id=>1} if $1 == '1'
         a << {:tag_id=>2} if $1 != '3'
@@ -32,7 +33,8 @@ describe "Sequel::Plugins::AssociationPks" do
         a
       when "SELECT year, week FROM hits WHERE ((hits.first = 'F1') AND (hits.last = 'L1'))"
         [{:year=>1997, :week=>1}, {:year=>1997, :week=>2}]
-      when /SELECT year, week FROM vocalists_hits WHERE \(\((?:first|last) = '?[FL1](\d)/
+      when /SELECT year, week FROM vocalists_hits WHERE \(\((?:first|last) = '?[FL1](\d)/,
+           /SELECT hits.year, hits.week FROM hits INNER JOIN vocalists_hits ON \(\(vocalists_hits.(?:year|week) = hits.(?:year|week)\) AND \(vocalists_hits.(?:year|week) = hits.(?:year|week)\)\) WHERE \(\(vocalists_hits.(?:first|last) = '?[FL1](\d)/
         a = []
         a << {:year=>1997, :week=>1} if $1 == "1"
         a << {:year=>1997, :week=>2} if $1 != "3"
@@ -64,13 +66,28 @@ describe "Sequel::Plugins::AssociationPks" do
 
   it "should return correct associated pks for one_to_many associations" do
     @Artist.load(:id=>1).album_pks.must_equal [1,2,3]
+    @db.sqls.must_equal ["SELECT id FROM albums WHERE (albums.artist_id = 1)"]
     @Artist.load(:id=>2).album_pks.must_equal []
+    @db.sqls.must_equal ["SELECT id FROM albums WHERE (albums.artist_id = 2)"]
   end
 
   it "should return correct associated pks for many_to_many associations" do
     @Album.load(:id=>1).tag_pks.must_equal [1, 2]
+    @db.sqls.must_equal ["SELECT tag_id FROM albums_tags WHERE (album_id = 1)"]
     @Album.load(:id=>2).tag_pks.must_equal [2, 3]
+    @db.sqls.must_equal ["SELECT tag_id FROM albums_tags WHERE (album_id = 2)"]
     @Album.load(:id=>3).tag_pks.must_equal []
+    @db.sqls.must_equal ["SELECT tag_id FROM albums_tags WHERE (album_id = 3)"]
+  end
+
+  it "should return correct associated pks for many_to_many associations using :association_pks_use_associated_table" do
+    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id, :delay_pks=>false, :association_pks_use_associated_table=>true
+    @Album.load(:id=>1).tag_pks.must_equal [1, 2]
+    @db.sqls.must_equal ["SELECT tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1)"]
+    @Album.load(:id=>2).tag_pks.must_equal [2, 3]
+    @db.sqls.must_equal ["SELECT tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 2)"]
+    @Album.load(:id=>3).tag_pks.must_equal []
+    @db.sqls.must_equal ["SELECT tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 3)"]
   end
 
   deprecated "should set associated pks correctly for a one_to_many association when :delay_pks is not set" do
@@ -171,14 +188,29 @@ describe "Sequel::Plugins::AssociationPks" do
   it "should return correct right-side associated cpks for left-side cpks for one_to_many associations" do
     @Vocalist.one_to_many :hits, :class=>@Hit, :key=>[:first, :last]
     @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.must_equal [[1997, 1], [1997, 2]]
+    @db.sqls.must_equal ["SELECT year, week FROM hits WHERE ((hits.first = 'F1') AND (hits.last = 'L1'))"]
     @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.must_equal []
+    @db.sqls.must_equal ["SELECT year, week FROM hits WHERE ((hits.first = 'F2') AND (hits.last = 'L2'))"]
   end
 
   it "should return correct right-side associated cpks for left-side cpks for many_to_many associations" do
     @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week]
     @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.must_equal [[1997, 1], [1997, 2]]
+    @db.sqls.must_equal ["SELECT year, week FROM vocalists_hits WHERE ((first = 'F1') AND (last = 'L1'))"]
+    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.must_equal [[1997, 2], [1997, 3]]
+    @db.sqls.must_equal ["SELECT year, week FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2'))"]
+    @Vocalist.load(:first=>'F3', :last=>'L3').hit_pks.must_equal []
+    @db.sqls.must_equal ["SELECT year, week FROM vocalists_hits WHERE ((first = 'F3') AND (last = 'L3'))"]
+  end
+
+  it "should return correct right-side associated cpks for left-side cpks for many_to_many associations when using :association_pks_use_associated_table" do
+    @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week], :association_pks_use_associated_table=>true
+    @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.must_equal [[1997, 1], [1997, 2]]
+    @db.sqls.must_equal ["SELECT hits.year, hits.week FROM hits INNER JOIN vocalists_hits ON ((vocalists_hits.year = hits.year) AND (vocalists_hits.week = hits.week)) WHERE ((vocalists_hits.first = 'F1') AND (vocalists_hits.last = 'L1'))"]
     @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.must_equal [[1997, 2], [1997, 3]]
+    @db.sqls.must_equal ["SELECT hits.year, hits.week FROM hits INNER JOIN vocalists_hits ON ((vocalists_hits.year = hits.year) AND (vocalists_hits.week = hits.week)) WHERE ((vocalists_hits.first = 'F2') AND (vocalists_hits.last = 'L2'))"]
     @Vocalist.load(:first=>'F3', :last=>'L3').hit_pks.must_equal []
+    @db.sqls.must_equal ["SELECT hits.year, hits.week FROM hits INNER JOIN vocalists_hits ON ((vocalists_hits.year = hits.year) AND (vocalists_hits.week = hits.week)) WHERE ((vocalists_hits.first = 'F3') AND (vocalists_hits.last = 'L3'))"]
   end
 
   it "should set associated right-side cpks correctly for left-side cpks for a one_to_many association" do

data/spec/extensions/auto_literal_strings_spec.rb

@@ -9,6 +9,10 @@ describe "Dataset#where" do
     @dataset.where('price < ? AND id in ?', 100, [1, 2, 3]).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
   end
   
+  it "should use default behavior for array of conditions" do
+    @dataset.where([[:a, 1], [:b, 2]]).sql.must_equal 'SELECT * FROM test WHERE ((a = 1) AND (b = 2))'
+  end
+
   it "should not modify passed array with placeholders" do
     a = ['price < ? AND id in ?', 100, 1, 2, 3]
     b = a.dup
@@ -114,7 +118,7 @@ describe "Dataset#and" do
     @d1 = @dataset.where(:x => 1)
   end
 
-  it "should accept string filters with placeholders" do
+  deprecated "should accept string filters with placeholders" do
     @d1.and('y > ?', 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
   end
 end

data/spec/extensions/auto_validations_spec.rb

@@ -98,6 +98,8 @@ describe "Sequel::Plugins::AutoValidations" do
     @m = @c.new
     @c.skip_auto_validations(:not_null)
     @m.valid?.must_equal true
+    @m.nnd = nil
+    @m.valid?.must_equal true
 
     @m.set(:d=>'/', :num=>'a', :name=>'1')
     @m.valid?.must_equal false

data/spec/extensions/boolean_readers_spec.rb

@@ -86,7 +86,7 @@ describe Sequel::Model, "BooleanReaders plugin" do
   end
 
   it "should handle cases where getting the columns raises an error" do
-    @c.meta_def(:columns){raise Sequel::Error}
+    def @c.columns; raise Sequel::Error end
     @c.plugin(:boolean_readers)
     proc{@c.new.b?}.must_raise(NoMethodError)
   end

data/spec/extensions/boolean_subsets_spec.rb

@@ -40,7 +40,7 @@ describe "boolean_subsets plugin" do
   end
 
   it "should handle cases where getting the columns raises an error" do
-    @c.meta_def(:columns){raise Sequel::Error}
+    def @c.columns; raise Sequel::Error end
     @c.plugin(:boolean_subsets)
     @c.respond_to?(:active).must_equal false
   end