sequel 4.47.0 → 4.48.0

data/spec/adapters/sqlite_spec.rb

@@ -134,7 +134,7 @@ describe "An SQLite database" do
     @db.create_table!(:fk){timestamp :t; datetime :d}
     @db.use_timestamp_timezones = true
     t1 = Time.at(1)
-    @db[:fk] << {:t => t1, :d => t1}
+    @db[:fk].insert(:t => t1, :d => t1)
     @db[:fk].map(:t).must_equal [t1]
     @db[:fk].map(:d).must_equal [t1]
     Sequel.datetime_class = DateTime
@@ -145,9 +145,9 @@ describe "An SQLite database" do
   
   it "should support sequential primary keys" do
     @db.create_table!(:fk) {primary_key :id; text :name}
-    @db[:fk] << {:name => 'abc'}
-    @db[:fk] << {:name => 'def'}
-    @db[:fk] << {:name => 'ghi'}
+    @db[:fk].insert(:name => 'abc')
+    @db[:fk].insert(:name => 'def')
+    @db[:fk].insert(:name => 'ghi')
     @db[:fk].order(:name).all.must_equal [
       {:id => 1, :name => 'abc'},
       {:id => 2, :name => 'def'},
@@ -347,9 +347,9 @@ describe "SQLite::Dataset#delete" do
     end
     @d = DB[:items]
     @d.delete # remove all records
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'def', :value => 4.56}
-    @d << {:name => 'ghi', :value => 7.89}
+    @d.insert(:name => 'abc', :value => 1.23)
+    @d.insert(:name => 'def', :value => 4.56)
+    @d.insert(:name => 'ghi', :value => 7.89)
   end
   after do
     DB.drop_table?(:items)
@@ -382,9 +382,9 @@ describe "SQLite::Dataset#update" do
     end
     @d = DB[:items]
     @d.delete # remove all records
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'def', :value => 4.56}
-    @d << {:name => 'ghi', :value => 7.89}
+    @d.insert(:name => 'abc', :value => 1.23)
+    @d.insert(:name => 'def', :value => 4.56)
+    @d.insert(:name => 'ghi', :value => 7.89)
   end
   
   it "should return the number of records affected" do
@@ -444,16 +444,16 @@ describe "SQLite dataset" do
       Float :value
     end
     @d = DB[:items]
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'def', :value => 4.56}
-    @d << {:name => 'ghi', :value => 7.89}
+    @d.insert(:name => 'abc', :value => 1.23)
+    @d.insert(:name => 'def', :value => 4.56)
+    @d.insert(:name => 'ghi', :value => 7.89)
   end
   after do
     DB.drop_table?(:test, :items)
   end
   
   it "should be able to insert from a subquery" do
-    DB[:test] << @d
+    DB[:test].insert(@d)
     DB[:test].count.must_equal 3
     DB[:test].select(:name, :value).order(:value).to_a.must_equal \
       @d.select(:name, :value).order(:value).to_a
@@ -484,21 +484,21 @@ describe "A SQLite database" do
     @db.add_column :test2, :xyz, :text
     
     @db[:test2].columns.must_equal [:name, :value, :xyz]
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz=>'000'}
+    @db[:test2].insert(:name => 'mmm', :value => 111, :xyz=>'000')
     @db[:test2].first.must_equal(:name => 'mmm', :value => 111, :xyz=>'000')
   end
   
   it "should support drop_column operations" do
     @db.drop_column :test2, :value
     @db[:test2].columns.must_equal [:name]
-    @db[:test2] << {:name => 'mmm'}
+    @db[:test2].insert(:name => 'mmm')
     @db[:test2].first.must_equal(:name => 'mmm')
   end
   
   it "should support drop_column operations in a transaction" do
     @db.transaction{@db.drop_column :test2, :value}
     @db[:test2].columns.must_equal [:name]
-    @db[:test2] << {:name => 'mmm'}
+    @db[:test2].insert(:name => 'mmm')
     @db[:test2].first.must_equal(:name => 'mmm')
   end
 
@@ -506,9 +506,9 @@ describe "A SQLite database" do
     @db.create_table!(:test2){Integer :a; Integer :b; Integer :c; primary_key [:a, :b]}
     @db.drop_column :test2, :c
     @db[:test2].columns.must_equal [:a, :b]
-    @db[:test2] << {:a=>1, :b=>2}
-    @db[:test2] << {:a=>2, :b=>3}
-    proc{@db[:test2] << {:a=>2, :b=>3}}.must_raise(Sequel::UniqueConstraintViolation, Sequel::ConstraintViolation, Sequel::DatabaseError)
+    @db[:test2].insert(:a=>1, :b=>2)
+    @db[:test2].insert(:a=>2, :b=>3)
+    proc{@db[:test2].insert(:a=>2, :b=>3)}.must_raise(Sequel::UniqueConstraintViolation, Sequel::ConstraintViolation, Sequel::DatabaseError)
   end
 
   it "should keep column attributes when dropping a column" do
@@ -520,9 +520,9 @@ describe "A SQLite database" do
 
     # This lame set of additions and deletions are to test that the primary keys
     # don't get messed up when we recreate the database.
-    @db[:test3] << { :name => "foo", :value => 1}
-    @db[:test3] << { :name => "foo", :value => 2}
-    @db[:test3] << { :name => "foo", :value => 3}
+    @db[:test3].insert( :name => "foo", :value => 1)
+    @db[:test3].insert( :name => "foo", :value => 2)
+    @db[:test3].insert( :name => "foo", :value => 3)
     @db[:test3].filter(:id => 2).delete
 
     @db.drop_column :test3, :value
@@ -558,7 +558,7 @@ describe "A SQLite database" do
   it "should support rename_column operations" do
     @db[:test2].delete
     @db.add_column :test2, :xyz, :text
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 'qqqq'}
+    @db[:test2].insert(:name => 'mmm', :value => 111, :xyz => 'qqqq')
 
     @db[:test2].columns.must_equal [:name, :value, :xyz]
     @db.rename_column :test2, :xyz, :zyx, :type => :text
@@ -717,4 +717,9 @@ describe "A SQLite database" do
     @db[:test2].insert(:name=>'a')
     proc{@db[:test2].insert(:name=>'a')}.must_raise(Sequel::ConstraintViolation, Sequel::UniqueConstraintViolation)
   end
+
+  it "should show unique constraints in Database#indexes" do
+    @db.alter_table(:test2){add_unique_constraint :name}
+    @db.indexes(:test2).values.first[:columns].must_equal [:name]
+  end if DB.sqlite_version >= 30808
 end

data/spec/core/connection_pool_spec.rb

@@ -259,6 +259,23 @@ ThreadedConnectionPoolSpecs = shared_description do
     t.join
   end
 
+  it "should work when acquire fails and then succeeds" do
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>2, :pool_timeout=>0))
+    def pool._acquire(*)
+      if @called
+        super
+      else
+        @called = true
+        nil
+      end
+    end
+    c = nil
+    pool.hold do |c1|
+      c = c1
+    end
+    c.wont_be_nil
+  end
+
   it "should wait until a connection is available if all are checked out" do
     pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>1, :pool_timeout=>0.1, :pool_sleep_time=>0))
     q, q1 = Queue.new, Queue.new

data/spec/core/database_spec.rb

@@ -12,6 +12,12 @@ describe "A new Database" do
     end
   end
   
+  deprecated "should support DatasetClass constant" do
+    dbc = Class.new(Sequel::Database)
+    dbc::DatasetClass = dsc = Class.new(Sequel::Dataset)
+    dbc.new.dataset.must_be_kind_of(dsc)
+  end
+
   deprecated "should allow dup/clone" do
     @db.dup.must_be_kind_of @db.class
     @db.clone.must_be_kind_of @db.class

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
@@ -1976,46 +1976,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 +2031,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 +2760,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 +2770,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 +2795,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 +2805,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 +2813,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 +3246,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 +3916,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 +3931,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 +3945,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 +3953,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 +3972,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)',

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