sequel 4.49.0 → 5.0.0

data/spec/core/object_graph_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+require_relative "spec_helper"
 
 describe Sequel::Dataset, "graphing" do
   before do
@@ -212,11 +212,8 @@ describe Sequel::Dataset, "graphing" do
       ds.sql.must_equal 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON ((lines.x = points.id) AND (lines.y = points.id))'
     end
 
-    deprecated "should not add columns if graph is called after set_graph_aliases" do
-      ds = @ds1.set_graph_aliases([[:x,[:points, :x]], [:y,[:lines, :y]]])
-      ds.sql.must_equal 'SELECT points.x, lines.y FROM points'
-      ds = ds.graph(:lines, :x=>:id)
-      ds.sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    it "should raise Error if set_graph_aliases is called on an ungraphed dataset" do
+      proc{@ds1.set_graph_aliases([[:x,[:points, :x]], [:y,[:lines, :y]]])}.must_raise Sequel::Error
     end
 
     it "should allow graphing of multiple datasets" do
@@ -243,15 +240,6 @@ describe Sequel::Dataset, "graphing" do
   end
 
   describe "#set_graph_aliases" do
-    deprecated "should not modify the current dataset's opts" do
-      o1 = @ds1.opts
-      o2 = o1.dup
-      ds1 = @ds1.set_graph_aliases(:x=>[:graphs,:id])
-      @ds1.opts.must_equal o1
-      @ds1.opts.must_equal o2
-      ds1.opts.wont_equal o1
-    end
-
     it "should not modify the current dataset's opts" do
       o1 = @ds1.opts
       o2 = o1.dup
@@ -264,69 +252,32 @@ describe Sequel::Dataset, "graphing" do
     it "should specify the graph mapping" do
       ds = @ds1.graph(:lines, :x=>:id)
       ds.sql.must_equal 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-      ds = ds.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
-      ['SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
-      'SELECT lines.y, points.x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-      ].must_include(ds.sql)
+      ds.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     end
 
     it "should allow a third entry to specify an expression to use other than the default" do
-      ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x, 1], :y=>[:lines, :y, Sequel.function(:random)])
-      ['SELECT 1 AS x, random() AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
-      'SELECT random() AS y, 1 AS x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-      ].must_include(ds.sql)
+      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x, 1], :y=>[:lines, :y, Sequel.function(:random)]).sql.must_equal 'SELECT 1 AS x, random() AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     end
 
     it "should allow a single array entry to specify a table, assuming the same column as the key" do
-      ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines])
-      ['SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
-      'SELECT lines.y, points.x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-      ].must_include(ds.sql)
+      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     end
 
     it "should allow hash values to be symbols specifying table, assuming the same column as the key" do
-      ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines)
-      ['SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
-      'SELECT lines.y, points.x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-      ].must_include(ds.sql)
+      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     end
 
-    deprecated "should only alias columns if necessary" do
-      ds = @ds1.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
-      ['SELECT points.x, lines.y FROM points',
-      'SELECT lines.y, points.x FROM points'
-      ].must_include(ds.sql)
-
-      ds = @ds1.set_graph_aliases(:x1=>[:points, :x], :y=>[:lines, :y])
-      ['SELECT points.x AS x1, lines.y FROM points',
-      'SELECT lines.y, points.x AS x1 FROM points'
-      ].must_include(ds.sql)
+    it "should only alias columns if necessary" do
+      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     end
 
     it "should only alias columns if necessary" do
-      ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
-      ['SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
-      'SELECT lines.y, points.x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-      ].must_include(ds.sql)
-
-      ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x1=>[:points, :x], :y=>[:lines, :y])
-      ['SELECT points.x AS x1, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
-      'SELECT lines.y, points.x AS x1 FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-      ].must_include(ds.sql)
+      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+      @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x1=>[:points, :x], :y=>[:lines, :y]).sql.must_equal 'SELECT points.x AS x1, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
     end
   end
 
   describe "#add_graph_aliases" do
-    deprecated "should not modify the current dataset's opts" do
-      ds1 = @ds1.set_graph_aliases(:x=>[:graphs,:id])
-      o1 = ds1.opts
-      o2 = o1.dup
-      ds2 = ds1.add_graph_aliases(:y=>[:blah,:id])
-      ds1.opts.must_equal o1
-      ds1.opts.must_equal o2
-      ds2.opts.wont_equal o1
-    end
-
     it "should not modify the current dataset's opts" do
       ds1 = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:graphs,:id])
       o1 = ds1.opts

data/spec/core/placeholder_literalizer_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe "Dataset::PlaceholderLiteralizer" do
   before do
@@ -56,12 +56,6 @@ describe "Dataset::PlaceholderLiteralizer" do
     @db.sqls.must_equal ["SELECT * FROM items WHERE (id = 1)", "SELECT * FROM items WHERE a(b)"]
   end
   
-  deprecated "should handle calls with a literal strings used as filter arguments" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg)}
-    loader.first("a = 1").must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)"]
-  end
-  
   it "should handle calls with a literal strings used as filter arguments" do
     loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg)}
     loader.first(Sequel.lit("a = 1")).must_equal @h
@@ -83,13 +77,6 @@ describe "Dataset::PlaceholderLiteralizer" do
     @db.sqls.must_equal ["SELECT * FROM items WHERE ((a = 1) AND (b = 1))", "SELECT * FROM items WHERE ((a = 2) AND (b = 2))"]
   end
   
-  deprecated "should handle calls with a placeholder used multiple times in different capacities" do
-    loader = @c.loader(@ds){|pl, ds| a = pl.arg; ds.where(a).where(:b=>a)}
-    loader.first("a = 1").must_equal @h
-    loader.first(["a = ?", 2]).must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE ((a = 1) AND (b = 'a = 1'))", "SELECT * FROM items WHERE ((a = 2) AND (b IN ('a = ?', 2)))"]
-  end
-  
   it "should handle calls with a placeholder used multiple times in different capacities" do
     loader = @c.loader(@ds){|pl, ds| a = pl.arg; ds.select(a).where(:b=>a)}
     loader.first("a").must_equal @h

data/spec/core/schema_generator_spec.rb

@@ -1,27 +1,39 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+require_relative "spec_helper"
 
 describe Sequel::Schema::CreateTableGenerator do
   before do
     @generator = Sequel::Schema::CreateTableGenerator.new(Sequel.mock) do
-      string :title
-      column :body, :text
-      foreign_key :parent_id
-      primary_key :id
-      check 'price > 100'
-      constraint(:xxx) {{:yyy => :zzz}}
-      index :title
-      index [:title, :body], :unique => true
-      foreign_key :node_id, :nodes
-      foreign_key :deferrable_node_id, :nodes, :deferrable => true
-      primary_key [:title, :parent_id], :name => :cpk
-      foreign_key [:node_id, :prop_id], :nodes_props, :name => :cfk
+      string(:title).must_be_nil
+      column(:body, :text).must_be_nil
+      foreign_key(:parent_id).must_be_nil
+      primary_key(:id).must_be_nil
+      check('price > 100').must_be_nil
+      constraint(:xxx){{:yyy => :zzz}}.must_be_nil
+      index(:title).must_be_nil
+      index([:title, :body], :unique => true).must_be_nil
+      foreign_key(:node_id, :nodes).must_be_nil
+      foreign_key(:deferrable_node_id, :nodes, :deferrable => true).must_be_nil
+      primary_key([:title, :parent_id], :name => :cpk).must_be_nil
+      foreign_key([:node_id, :prop_id], :nodes_props, :name => :cfk).must_be_nil
     end
     @columns, @indexes, @constraints = @generator.columns, @generator.indexes, @generator.constraints
   end
   
   it "should respond to everything" do
     @generator.respond_to?(:foo).must_equal true
-  end if RUBY_VERSION >= '1.9'
+  end
+
+  it "should respond adding types" do
+    c = Class.new(Sequel::Schema::CreateTableGenerator)
+    c2 = Class.new
+    def c2.to_s; 'Foo' end
+    c.add_type_method(c2)
+    gen = c.new(Sequel.mock) do
+      Foo :bar
+    end
+
+    gen.columns.first.values_at(:name, :type).must_equal [:bar, c2]
+  end
 
   it "should primary key column first" do
     @columns.first[:name].must_equal :id
@@ -117,38 +129,37 @@ describe Sequel::Schema::CreateTableGenerator do
   end
   
   it "creates indexes" do
-    @indexes[0][:columns].must_include(:title)
-    @indexes[1][:columns].must_include(:title)
-    @indexes[1][:columns].must_include(:body)
+    @indexes[0][:columns].must_equal [:title]
+    @indexes[1][:columns].must_equal [:title, :body]
   end
 end
 
 describe Sequel::Schema::AlterTableGenerator do
   before do
     @generator = Sequel::Schema::AlterTableGenerator.new(Sequel.mock) do
-      add_column :aaa, :text
-      drop_column :bbb
-      rename_column :ccc, :ho
-      set_column_type :ddd, :float
-      set_column_default :eee, 1
-      add_index [:fff, :ggg]
-      drop_index :hhh
-      drop_index :hhh, :name=>:blah_blah
-      add_full_text_index :blah
-      add_spatial_index :geom
-      add_index :blah, :type => :hash
-      add_index :blah, :where => {:something => true}
-      add_constraint :con1, 'fred > 100'
-      drop_constraint :con2
-      add_unique_constraint [:aaa, :bbb, :ccc], :name => :con3
-      add_primary_key :id
-      add_foreign_key :node_id, :nodes
-      add_primary_key [:aaa, :bbb]
-      add_foreign_key [:node_id, :prop_id], :nodes_props
-      add_foreign_key [:node_id, :prop_id], :nodes_props, :name => :fkey
-      drop_foreign_key :node_id
-      drop_foreign_key [:node_id, :prop_id]
-      drop_foreign_key [:node_id, :prop_id], :name => :fkey
+      add_column(:aaa, :text).must_be_nil
+      drop_column(:bbb).must_be_nil
+      rename_column(:ccc, :ho).must_be_nil
+      set_column_type(:ddd, :float).must_be_nil
+      set_column_default(:eee, 1).must_be_nil
+      add_index([:fff, :ggg]).must_be_nil
+      drop_index(:hhh).must_be_nil
+      drop_index(:hhh, :name=>:blah_blah).must_be_nil
+      add_full_text_index(:blah).must_be_nil
+      add_spatial_index(:geom).must_be_nil
+      add_index(:blah, :type => :hash).must_be_nil
+      add_index(:blah, :where => {:something => true}).must_be_nil
+      add_constraint(:con1, 'fred > 100').must_be_nil
+      drop_constraint(:con2).must_be_nil
+      add_unique_constraint([:aaa, :bbb, :ccc], :name => :con3).must_be_nil
+      add_primary_key(:id).must_be_nil
+      add_foreign_key(:node_id, :nodes).must_be_nil
+      add_primary_key([:aaa, :bbb]).must_be_nil
+      add_foreign_key([:node_id, :prop_id], :nodes_props).must_be_nil
+      add_foreign_key([:node_id, :prop_id], :nodes_props, :name => :fkey).must_be_nil
+      drop_foreign_key(:node_id).must_be_nil
+      drop_foreign_key([:node_id, :prop_id]).must_be_nil
+      drop_foreign_key([:node_id, :prop_id], :name => :fkey).must_be_nil
     end
   end
   

data/spec/core/schema_spec.rb

@@ -1,17 +1,12 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+require_relative "spec_helper"
 
 describe "DB#create_table" do
   before 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.create_table(:cats){}.must_be_nil
     @db.sqls.must_equal ['CREATE TABLE cats ()']
   end
 
@@ -514,15 +509,22 @@ describe "DB#create_table" do
   end
 
   it "should ignore errors if the database raises an error on an index creation statement and the :ignore_index_errors option is used" do
-    meta_def(@db, :execute_ddl){|*a| raise Sequel::DatabaseError if /blah/.match(a.first); super(*a)}
+    @db.define_singleton_method(:execute_ddl){|*a| raise Sequel::DatabaseError if /blah/.match(a.first); super(*a)}
     lambda{@db.create_table(:cats){Integer :id; index :blah; index :id}}.must_raise(Sequel::DatabaseError)
     @db.sqls.must_equal ['CREATE TABLE cats (id integer)']
     @db.create_table(:cats, :ignore_index_errors=>true){Integer :id; index :blah; index :id}
     @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)}
+  it "should not use savepoints around index creation if running inside a transaction if :ignore_index_errors option is used" do
+    @db.define_singleton_method(: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)", "CREATE INDEX cats_blah_index ON cats (blah)", "CREATE INDEX cats_id_index ON cats (id)", "COMMIT"]
+  end
+
+  it "should use savepoints around index creation if running inside a transaction if :ignore_index_errors option is used and transactional schema modifications are supported" do
+    @db.define_singleton_method(:supports_transactional_ddl?){true}
+    @db.define_singleton_method(: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
@@ -613,7 +615,7 @@ describe "DB#create_table" do
     @db.sqls.must_equal ["CREATE TABLE cats (CHECK (price = 100))"]
   end
 
-  deprecated "should accept array constraints" do
+  it "should accept array constraints" do
     @db.create_table(:cats) do
       check [Sequel.expr(:x) > 0, Sequel.expr(:y) < 1]
     end
@@ -757,19 +759,19 @@ describe "DB#create_table!" do
   end
   
   it "should create the table if it does not exist" do
-    meta_def(@db, :table_exists?){|a| false}
-    @db.create_table!(:cats){|*a|}
+    @db.define_singleton_method(:table_exists?){|a| false}
+    @db.create_table!(:cats){|*a|}.must_be_nil
     @db.sqls.must_equal ['CREATE TABLE cats ()']
   end
   
   it "should drop the table before creating it if it already exists" do
-    meta_def(@db, :table_exists?){|a| true}
+    @db.define_singleton_method(:table_exists?){|a| true}
     @db.create_table!(:cats){|*a|}
     @db.sqls.must_equal ['DROP TABLE cats', 'CREATE TABLE cats ()']
   end
   
   it "should use IF EXISTS if the database supports it" do
-    meta_def(@db, :supports_drop_table_if_exists?){true}
+    @db.define_singleton_method(:supports_drop_table_if_exists?){true}
     @db.create_table!(:cats){|*a|}
     @db.sqls.must_equal ['DROP TABLE IF EXISTS cats', 'CREATE TABLE cats ()']
   end
@@ -781,30 +783,30 @@ describe "DB#create_table?" do
   end
   
   it "should not create the table if the table already exists" do
-    meta_def(@db, :table_exists?){|a| true}
-    @db.create_table?(:cats){|*a|}
+    @db.define_singleton_method(:table_exists?){|a| true}
+    @db.create_table?(:cats){|*a|}.must_be_nil
     @db.sqls.must_equal []
   end
   
   it "should create the table if the table doesn't already exist" do
-    meta_def(@db, :table_exists?){|a| false}
+    @db.define_singleton_method(:table_exists?){|a| false}
     @db.create_table?(:cats){|*a|}
     @db.sqls.must_equal ['CREATE TABLE cats ()']
   end
   
   it "should use IF NOT EXISTS if the database supports that" do
-    meta_def(@db, :supports_create_table_if_not_exists?){true}
+    @db.define_singleton_method(:supports_create_table_if_not_exists?){true}
     @db.create_table?(:cats){|*a|}
     @db.sqls.must_equal ['CREATE TABLE IF NOT EXISTS cats ()']
   end
   
   it "should not use IF NOT EXISTS if the indexes are created" do
-    meta_def(@db, :table_exists?){|a| false}
-    meta_def(@db, :supports_create_table_if_not_exists?){true}
+    @db.define_singleton_method(:table_exists?){|a| false}
+    @db.define_singleton_method(:supports_create_table_if_not_exists?){true}
     @db.create_table?(:cats){|*a| Integer :a, :index=>true}
     @db.sqls.must_equal ['CREATE TABLE cats (a integer)', 'CREATE INDEX cats_a_index ON cats (a)']
 
-    meta_def(@db, :table_exists?){|a| true}
+    @db.define_singleton_method(:table_exists?){|a| true}
     @db.create_table?(:cats){|*a| Integer :a, :index=>true}
     @db.sqls.must_equal []
   end
@@ -816,7 +818,7 @@ describe "DB#create_join_table" do
   end
   
   it "should take a hash with foreign keys and table name values" do
-    @db.create_join_table(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.create_join_table(:cat_id=>:cats, :dog_id=>:dogs).must_be_nil
     @db.sqls.must_equal ['CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
   end
   
@@ -864,30 +866,30 @@ describe "DB#create_join_table?" do
   end
   
   it "should create the table if it does not already exist" do
-    meta_def(@db, :table_exists?){|a| false}
-    @db.create_join_table?(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.define_singleton_method(:table_exists?){|a| false}
+    @db.create_join_table?(:cat_id=>:cats, :dog_id=>:dogs).must_be_nil
     @db.sqls.must_equal ['CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
   end
 
   it "should not create the table if it already exists" do
-    meta_def(@db, :table_exists?){|a| true}
+    @db.define_singleton_method(:table_exists?){|a| true}
     @db.create_join_table?(:cat_id=>:cats, :dog_id=>:dogs)
     @db.sqls.must_equal []
   end
 
   it "should not use IF NOT EXISTS" do
-    meta_def(@db, :table_exists?){|a| false}
-    meta_def(@db, :supports_create_table_if_not_exists?){true}
+    @db.define_singleton_method(:table_exists?){|a| false}
+    @db.define_singleton_method(:supports_create_table_if_not_exists?){true}
     @db.create_join_table?(:cat_id=>:cats, :dog_id=>:dogs)
     @db.sqls.must_equal ['CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
 
-    meta_def(@db, :table_exists?){|a| true}
+    @db.define_singleton_method(:table_exists?){|a| true}
     @db.create_join_table?(:cat_id=>:cats, :dog_id=>:dogs)
     @db.sqls.must_equal []
   end
 
   it "should not use IF NOT EXISTS if no_index is used" do
-    meta_def(@db, :supports_create_table_if_not_exists?){true}
+    @db.define_singleton_method(:supports_create_table_if_not_exists?){true}
     @db.create_join_table?({:cat_id=>:cats, :dog_id=>:dogs}, :no_index=>true)
     @db.sqls.must_equal ['CREATE TABLE IF NOT EXISTS cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))']
   end
@@ -899,19 +901,19 @@ describe "DB#create_join_table!" do
   end
   
   it "should drop the table first if it already exists" do
-    meta_def(@db, :table_exists?){|a| true}
-    @db.create_join_table!(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.define_singleton_method(:table_exists?){|a| true}
+    @db.create_join_table!(:cat_id=>:cats, :dog_id=>:dogs).must_be_nil
     @db.sqls.must_equal ['DROP TABLE cats_dogs', 'CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
   end
 
   it "should not drop the table if it doesn't exists" do
-    meta_def(@db, :table_exists?){|a| false}
+    @db.define_singleton_method(:table_exists?){|a| false}
     @db.create_join_table!(:cat_id=>:cats, :dog_id=>:dogs)
     @db.sqls.must_equal ['CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
   end
 
   it "should use IF EXISTS if the database supports it" do
-    meta_def(@db, :supports_drop_table_if_exists?){true}
+    @db.define_singleton_method(:supports_drop_table_if_exists?){true}
     @db.create_join_table!(:cat_id=>:cats, :dog_id=>:dogs)
     @db.sqls.must_equal ['DROP TABLE IF EXISTS cats_dogs', 'CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
   end
@@ -923,7 +925,7 @@ describe "DB#drop_join_table" do
   end
   
   it "should take a hash with foreign keys and table name values and drop the table" do
-    @db.drop_join_table(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.drop_join_table(:cat_id=>:cats, :dog_id=>:dogs).must_be_nil
     @db.sqls.must_equal ['DROP TABLE cats_dogs']
   end
   
@@ -956,7 +958,7 @@ describe "DB#drop_table" do
   end
 
   it "should generate a DROP TABLE statement" do
-    @db.drop_table :cats
+    @db.drop_table(:cats).must_be_nil
     @db.sqls.must_equal ['DROP TABLE cats']
   end
 
@@ -977,37 +979,37 @@ describe "DB#drop_table?" do
   end
   
   it "should drop the table if it exists" do
-    meta_def(@db, :table_exists?){|a| true}
-    @db.drop_table?(:cats)
+    @db.define_singleton_method(:table_exists?){|a| true}
+    @db.drop_table?(:cats).must_be_nil
     @db.sqls.must_equal ["DROP TABLE cats"]
   end
   
   it "should do nothing if the table does not exist" do
-    meta_def(@db, :table_exists?){|a| false}
+    @db.define_singleton_method(:table_exists?){|a| false}
     @db.drop_table?(:cats)
     @db.sqls.must_equal []
   end
   
   it "should operate on multiple tables at once" do
-    meta_def(@db, :table_exists?){|a| a == :cats}
+    @db.define_singleton_method(:table_exists?){|a| a == :cats}
     @db.drop_table? :cats, :dogs
     @db.sqls.must_equal ['DROP TABLE cats']
   end
 
   it "should take an options hash and support the :cascade option" do
-    meta_def(@db, :table_exists?){|a| true}
+    @db.define_singleton_method(:table_exists?){|a| true}
     @db.drop_table? :cats, :dogs, :cascade=>true
     @db.sqls.must_equal ['DROP TABLE cats CASCADE', 'DROP TABLE dogs CASCADE']
   end
 
   it "should use IF NOT EXISTS if the database supports that" do
-    meta_def(@db, :supports_drop_table_if_exists?){true}
+    @db.define_singleton_method(:supports_drop_table_if_exists?){true}
     @db.drop_table? :cats, :dogs
     @db.sqls.must_equal ['DROP TABLE IF EXISTS cats', 'DROP TABLE IF EXISTS dogs']
   end
 
   it "should use IF NOT EXISTS with CASCADE if the database supports that" do
-    meta_def(@db, :supports_drop_table_if_exists?){true}
+    @db.define_singleton_method(:supports_drop_table_if_exists?){true}
     @db.drop_table? :cats, :dogs, :cascade=>true
     @db.sqls.must_equal ['DROP TABLE IF EXISTS cats CASCADE', 'DROP TABLE IF EXISTS dogs CASCADE']
   end
@@ -1018,15 +1020,10 @@ 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
-    end
+    end.must_be_nil
     @db.sqls.must_equal ["ALTER TABLE cats ALTER COLUMN score SET NOT NULL"]
   end
   
@@ -1128,7 +1125,7 @@ describe "DB#alter_table" do
   end
 
   it "should ignore errors if the database raises an error on an add_index call and the :ignore_errors option is used" do
-    meta_def(@db, :execute_ddl){|*a| raise Sequel::DatabaseError}
+    @db.define_singleton_method(:execute_ddl){|*a| raise Sequel::DatabaseError}
     lambda{@db.add_index(:cats, :id)}.must_raise(Sequel::DatabaseError)
     @db.add_index(:cats, :id, :ignore_errors=>true)
     @db.sqls.must_equal []
@@ -1283,7 +1280,7 @@ describe "DB#alter_table" do
   end
 
   it "should combine operations into a single query if the database supports it" do
-    meta_def(@db, :supports_combining_alter_table_ops?){true}
+    @db.define_singleton_method(:supports_combining_alter_table_ops?){true}
     @db.alter_table(:cats) do
       add_column :a, Integer
       drop_column :b
@@ -1298,7 +1295,7 @@ describe "DB#alter_table" do
   end
   
   it "should combine operations into consecutive groups of combinable operations if the database supports combining operations" do
-    meta_def(@db, :supports_combining_alter_table_ops?){true}
+    @db.define_singleton_method(:supports_combining_alter_table_ops?){true}
     @db.alter_table(:cats) do
       add_column :a, Integer
       drop_column :b
@@ -1373,7 +1370,7 @@ end
 describe "Database#add_column" do
   it "should construct proper SQL" do
     db = Sequel.mock
-    db.add_column :test, :name, :text, :unique => true
+    db.add_column(:test, :name, :text, :unique => true).must_be_nil
     db.sqls.must_equal ['ALTER TABLE test ADD COLUMN name text UNIQUE']
   end
 end
@@ -1384,7 +1381,7 @@ describe "Database#drop_column" do
   end
   
   it "should construct proper SQL" do
-    @db.drop_column :test, :name
+    @db.drop_column(:test, :name).must_be_nil
     @db.sqls.must_equal ['ALTER TABLE test DROP COLUMN name']
   end
   
@@ -1400,7 +1397,7 @@ describe "Database#rename_column" do
   end
   
   it "should construct proper SQL" do
-    @db.rename_column :test, :abc, :def
+    @db.rename_column(:test, :abc, :def).must_be_nil
     @db.sqls.must_equal ['ALTER TABLE test RENAME COLUMN abc TO def']
   end
 end
@@ -1411,7 +1408,7 @@ describe "Database#set_column_type" do
   end
   
   it "should construct proper SQL" do
-    @db.set_column_type :test, :name, :integer
+    @db.set_column_type(:test, :name, :integer).must_be_nil
     @db.sqls.must_equal ['ALTER TABLE test ALTER COLUMN name TYPE integer']
   end
 end
@@ -1422,7 +1419,7 @@ describe "Database#set_column_default" do
   end
   
   it "should construct proper SQL" do
-    @db.set_column_default :test, :name, 'zyx'
+    @db.set_column_default(:test, :name, 'zyx').must_be_nil
     @db.sqls.must_equal ["ALTER TABLE test ALTER COLUMN name SET DEFAULT 'zyx'"]
   end
 end
@@ -1433,7 +1430,7 @@ describe "Database#add_index" do
   end
   
   it "should construct proper SQL" do
-    @db.add_index :test, :name, :unique => true
+    @db.add_index(:test, :name, :unique => true).must_be_nil
     @db.sqls.must_equal ['CREATE UNIQUE INDEX test_name_index ON test (name)']
   end
   
@@ -1449,7 +1446,7 @@ describe "Database#drop_index" do
   end
   
   it "should construct proper SQL" do
-    @db.drop_index :test, :name
+    @db.drop_index(:test, :name).must_be_nil
     @db.sqls.must_equal ['DROP INDEX test_name_index']
   end
   
@@ -1461,7 +1458,7 @@ describe "Database#drop_table" do
   end
   
   it "should construct proper SQL" do
-    @db.drop_table :test
+    @db.drop_table(:test).must_be_nil
     @db.sqls.must_equal ['DROP TABLE test']
   end
   
@@ -1477,7 +1474,7 @@ describe "Database#rename_table" do
   end
   
   it "should construct proper SQL" do
-    @db.rename_table :abc, :xyz
+    @db.rename_table(:abc, :xyz).must_be_nil
     @db.sqls.must_equal ['ALTER TABLE abc RENAME TO xyz']
   end
 end
@@ -1488,7 +1485,7 @@ describe "Database#create_view" do
   end
   
   it "should construct proper SQL with raw SQL" do
-    @db.create_view :test, "SELECT * FROM xyz"
+    @db.create_view(:test, "SELECT * FROM xyz").must_be_nil
     @db.sqls.must_equal ['CREATE VIEW test AS SELECT * FROM xyz']
     @db.create_view Sequel.identifier(:test), "SELECT * FROM xyz"
     @db.sqls.must_equal ['CREATE VIEW test AS SELECT * FROM xyz']
@@ -1540,7 +1537,7 @@ describe "Database#drop_view" do
   end
   
   with_symbol_splitting "should construct proper SQL for splittable symbols" do
-    @db.drop_view :sch__test
+    @db.drop_view(:sch__test).must_be_nil
     @db.sqls.must_equal ['DROP VIEW sch.test']
   end
 
@@ -1580,21 +1577,21 @@ describe "Schema Parser" do
   end
 
   it "should raise an error if there are no columns" do
-    meta_def(@db, :schema_parse_table) do |t, opts|
+    @db.define_singleton_method(:schema_parse_table) do |t, opts|
       []
     end
     proc{@db.schema(:x)}.must_raise(Sequel::Error)
   end
 
   it "should cache data by default" do
-    meta_def(@db, :schema_parse_table) do |t, opts|
+    @db.define_singleton_method(:schema_parse_table) do |t, opts|
       [[:a, {}]]
     end
     @db.schema(:x).must_be_same_as(@db.schema(:x))
   end
 
   it "should not cache data if :reload=>true is given" do
-    meta_def(@db, :schema_parse_table) do |t, opts|
+    @db.define_singleton_method(:schema_parse_table) do |t, opts|
       [[:a, {}]]
     end
     @db.schema(:x).wont_be_same_as(@db.schema(:x, :reload=>true))
@@ -1602,7 +1599,7 @@ describe "Schema Parser" do
 
   it "should not cache schema metadata if cache_schema is false" do
     @db.cache_schema = false
-    meta_def(@db, :schema_parse_table) do |t, opts|
+    @db.define_singleton_method(:schema_parse_table) do |t, opts|
       [[:a, {}]]
     end
     @db.schema(:x).wont_be_same_as(@db.schema(:x))
@@ -1610,7 +1607,7 @@ describe "Schema Parser" do
 
   it "should provide options if given a table name" do
     c = nil
-    meta_def(@db, :schema_parse_table) do |t, opts|
+    @db.define_singleton_method(:schema_parse_table) do |t, opts|
       c = [t, opts]
       [[:a, {:db_type=>t.to_s}]]
     end
@@ -1625,7 +1622,7 @@ describe "Schema Parser" do
 
   with_symbol_splitting "should provide options if given a table name with splittable symbols" do
     c = nil
-    meta_def(@db, :schema_parse_table) do |t, opts|
+    @db.define_singleton_method(:schema_parse_table) do |t, opts|
       c = [t, opts]
       [[:a, {:db_type=>t.to_s}]]
     end
@@ -1639,7 +1636,7 @@ describe "Schema Parser" do
   it "should parse the schema correctly for a single table" do
     sqls = @sqls
     proc{@db.schema(:x)}.must_raise(Sequel::Error)
-    meta_def(@db, :schema_parse_table) do |t, opts|
+    @db.define_singleton_method(:schema_parse_table) do |t, opts|
       sqls << t
       [[:a, {:db_type=>t.to_s}]]
     end
@@ -1652,33 +1649,33 @@ describe "Schema Parser" do
   end
 
   it "should set :auto_increment to true by default if unset and a single integer primary key is used" do
-    meta_def(@db, :schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer'}]]}
+    @db.define_singleton_method(:schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer'}]]}
     @db.schema(:x).first.last[:auto_increment].must_equal true
   end
 
   it "should not set :auto_increment if already set" do
-    meta_def(@db, :schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer', :auto_increment=>false}]]}
+    @db.define_singleton_method(:schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer', :auto_increment=>false}]]}
     @db.schema(:x).first.last[:auto_increment].must_equal false
   end
 
   it "should set :auto_increment to false by default if unset and a single nonintegery primary key is used" do
-    meta_def(@db, :schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'varchar'}]]}
+    @db.define_singleton_method(:schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'varchar'}]]}
     @db.schema(:x).first.last[:auto_increment].must_equal false
   end
 
   it "should set :auto_increment to false by default if unset and a composite primary key" do
-    meta_def(@db, :schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer'}], [:b, {:primary_key=>true, :db_type=>'integer'}]]}
+    @db.define_singleton_method(:schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer'}], [:b, {:primary_key=>true, :db_type=>'integer'}]]}
     @db.schema(:x).first.last[:auto_increment].must_equal false
     @db.schema(:x).last.last[:auto_increment].must_equal false
   end
 
   it "should set :auto_increment to true by default if set and not the first column" do
-    meta_def(@db, :schema_parse_table){|*| [[:b, {}], [:a, {:primary_key=>true, :db_type=>'integer'}]]}
+    @db.define_singleton_method(:schema_parse_table){|*| [[:b, {}], [:a, {:primary_key=>true, :db_type=>'integer'}]]}
     @db.schema(:x).last.last[:auto_increment].must_equal true
   end
 
   it "should convert various types of table name arguments" do
-    meta_def(@db, :schema_parse_table) do |t, opts|
+    @db.define_singleton_method(:schema_parse_table) do |t, opts|
       [[t, opts]]
     end
     s1 = @db.schema(:x)
@@ -1703,7 +1700,7 @@ describe "Schema Parser" do
   end
 
   with_symbol_splitting "should convert splittable symbol arguments" do
-    meta_def(@db, :schema_parse_table) do |t, opts|
+    @db.define_singleton_method(:schema_parse_table) do |t, opts|
       [[t, opts]]
     end
     s1 = @db.schema(:x)