sequel 4.41.0 → 4.42.0

data/spec/core/dataset_mutation_spec.rb

@@ -0,0 +1,253 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+# SEQUEL5: Remove
+unless Sequel.mock.dataset.frozen?
+
+describe "Dataset" do
+  before do
+    @d = Sequel.mock.dataset.from(:x)
+  end
+
+  it "should support self-changing select!" do
+    @d.select!(:y)
+    @d.sql.must_equal "SELECT y FROM x"
+  end
+  
+  it "should support self-changing from!" do
+    @d.from!(:y)
+    @d.sql.must_equal "SELECT * FROM y"
+  end
+
+  it "should support self-changing order!" do
+    @d.order!(:y)
+    @d.sql.must_equal "SELECT * FROM x ORDER BY y"
+  end
+  
+  it "should support self-changing filter!" do
+    @d.filter!(:y => 1)
+    @d.sql.must_equal "SELECT * FROM x WHERE (y = 1)"
+  end
+
+  it "should support self-changing filter! with block" do
+    @d.filter!{y < 2}
+    @d.sql.must_equal "SELECT * FROM x WHERE (y < 2)"
+  end
+  
+  it "should raise for ! methods that don't return a dataset" do
+    proc {@d.opts!}.must_raise(NoMethodError)
+  end
+  
+  it "should raise for missing methods" do
+    proc {@d.xuyz}.must_raise(NoMethodError)
+    proc {@d.xyz!}.must_raise(NoMethodError)
+    proc {@d.xyz?}.must_raise(NoMethodError)
+  end
+  
+  it "should support chaining of bang methods" do
+      @d.order!(:y).filter!(:y => 1).sql.must_equal "SELECT * FROM x WHERE (y = 1) ORDER BY y"
+  end
+end
+
+describe "Frozen Datasets" do
+  before do
+    @ds = Sequel.mock[:test].freeze
+  end
+
+  it "should have dups not be frozen" do
+    @ds.dup.wont_be :frozen?
+  end
+
+  it "should raise an error when calling mutation methods" do
+    proc{@ds.select!(:a)}.must_raise RuntimeError
+    proc{@ds.row_proc = proc{}}.must_raise RuntimeError
+    proc{@ds.extension! :query}.must_raise RuntimeError
+    proc{@ds.naked!}.must_raise RuntimeError
+    proc{@ds.from_self!}.must_raise RuntimeError
+  end
+end
+
+describe "Dataset mutation methods" do
+  def m(&block)
+    ds = Sequel.mock[:t]
+    def ds.supports_cte?(*) true end
+    ds.instance_exec(&block)
+    ds.sql
+  end
+
+  it "should modify the dataset in place" do
+    dsc = Sequel.mock[:u]
+    dsc.send(:columns=, [:v])
+
+    m{and!(:a=>1).or!(:b=>2)}.must_equal "SELECT * FROM t WHERE ((a = 1) OR (b = 2))"
+    m{select!(:f).graph!(dsc, :b=>:c).set_graph_aliases!(:e=>[:m, :n]).add_graph_aliases!(:d=>[:g, :c])}.must_equal "SELECT m.n AS e, g.c AS d FROM t LEFT OUTER JOIN u ON (u.b = t.c)"
+    m{cross_join!(:a)}.must_equal "SELECT * FROM t CROSS JOIN a"
+    m{distinct!}.must_equal "SELECT DISTINCT * FROM t"
+    m{except!(dsc)}.must_equal "SELECT * FROM (SELECT * FROM t EXCEPT SELECT * FROM u) AS t1"
+    m{exclude!(:a=>1)}.must_equal "SELECT * FROM t WHERE (a != 1)"
+    m{exclude_having!(:a=>1)}.must_equal "SELECT * FROM t HAVING (a != 1)"
+    m{exclude_where!(:a=>1)}.must_equal "SELECT * FROM t WHERE (a != 1)"
+    m{filter!(:a=>1)}.must_equal "SELECT * FROM t WHERE (a = 1)"
+    m{for_update!}.must_equal "SELECT * FROM t FOR UPDATE"
+    m{from!(:p)}.must_equal "SELECT * FROM p"
+    m{full_join!(:a, [:b])}.must_equal "SELECT * FROM t FULL JOIN a USING (b)"
+    m{full_outer_join!(:a, [:b])}.must_equal "SELECT * FROM t FULL OUTER JOIN a USING (b)"
+    m{grep!(:a, 'b')}.must_equal "SELECT * FROM t WHERE ((a LIKE 'b' ESCAPE '\\'))"
+    m{group!(:a)}.must_equal "SELECT * FROM t GROUP BY a"
+    m{group_and_count!(:a)}.must_equal "SELECT a, count(*) AS count FROM t GROUP BY a"
+    m{group_by!(:a)}.must_equal "SELECT * FROM t GROUP BY a"
+    m{having!(:a)}.must_equal "SELECT * FROM t HAVING a"
+    m{inner_join!(:a, [:b])}.must_equal "SELECT * FROM t INNER JOIN a USING (b)"
+    m{intersect!(dsc)}.must_equal "SELECT * FROM (SELECT * FROM t INTERSECT SELECT * FROM u) AS t1"
+    m{where!(:a).invert!}.must_equal "SELECT * FROM t WHERE NOT a"
+    m{join!(:a, [:b])}.must_equal "SELECT * FROM t INNER JOIN a USING (b)"
+    m{join_table!(:inner, :a, [:b])}.must_equal "SELECT * FROM t INNER JOIN a USING (b)"
+    m{left_join!(:a, [:b])}.must_equal "SELECT * FROM t LEFT JOIN a USING (b)"
+    m{left_outer_join!(:a, [:b])}.must_equal "SELECT * FROM t LEFT OUTER JOIN a USING (b)"
+    m{limit!(1)}.must_equal "SELECT * FROM t LIMIT 1"
+    m{lock_style!(:update)}.must_equal "SELECT * FROM t FOR UPDATE"
+    m{natural_full_join!(:a)}.must_equal "SELECT * FROM t NATURAL FULL JOIN a"
+    m{natural_join!(:a)}.must_equal "SELECT * FROM t NATURAL JOIN a"
+    m{natural_left_join!(:a)}.must_equal "SELECT * FROM t NATURAL LEFT JOIN a"
+    m{natural_right_join!(:a)}.must_equal "SELECT * FROM t NATURAL RIGHT JOIN a"
+    m{offset!(1)}.must_equal "SELECT * FROM t OFFSET 1"
+    m{order!(:a).reverse_order!}.must_equal "SELECT * FROM t ORDER BY a DESC"
+    m{order_by!(:a).order_more!(:b).order_append!(:c).order_prepend!(:d).reverse!}.must_equal "SELECT * FROM t ORDER BY d DESC, a DESC, b DESC, c DESC"
+    m{qualify!}.must_equal "SELECT t.* FROM t"
+    m{right_join!(:a, [:b])}.must_equal "SELECT * FROM t RIGHT JOIN a USING (b)"
+    m{right_outer_join!(:a, [:b])}.must_equal "SELECT * FROM t RIGHT OUTER JOIN a USING (b)"
+    m{select!(:a)}.must_equal "SELECT a FROM t"
+    m{select_all!(:t).select_more!(:b).select_append!(:c)}.must_equal "SELECT t.*, b, c FROM t"
+    m{select_group!(:a)}.must_equal "SELECT a FROM t GROUP BY a"
+    m{where!(:a).unfiltered!}.must_equal "SELECT * FROM t"
+    m{group!(:a).ungrouped!}.must_equal "SELECT * FROM t"
+    m{limit!(1).unlimited!}.must_equal "SELECT * FROM t"
+    m{order!(:a).unordered!}.must_equal "SELECT * FROM t"
+    m{union!(dsc)}.must_equal "SELECT * FROM (SELECT * FROM t UNION SELECT * FROM u) AS t1"
+    m{with!(:a, dsc)}.must_equal "WITH a AS (SELECT * FROM u) SELECT * FROM t"
+    m{with_recursive!(:a, dsc, dsc)}.must_equal "WITH a AS (SELECT * FROM u UNION ALL SELECT * FROM u) SELECT * FROM t"
+    m{with_sql!('SELECT foo')}.must_equal "SELECT foo"
+
+    dsc.server!(:a)
+    dsc.opts[:server].must_equal :a
+    dsc.graph!(dsc, {:b=>:c}, :table_alias=>:foo).ungraphed!.opts[:graph].must_be_nil
+  end
+
+  it "should clear the cache" do
+    ds = Sequel.mock[:a]
+    ds.columns
+    ds.send(:cache_set, :columns, [:a])
+    ds.select!(:foo, :bar).send(:cache_get, :columns).must_be_nil
+  end
+end
+
+describe "Dataset#clone" do
+  before do
+    @dataset = Sequel.mock.dataset.from(:items)
+  end
+
+  it "should copy the dataset opts" do
+    clone = @dataset.clone
+    clone.opts.must_equal @dataset.opts
+    @dataset.filter!(:a => 'b')
+    clone.opts[:filter].must_be_nil
+  end
+end
+  
+describe "Dataset extensions" do
+  before(:all) do
+    class << Sequel
+      alias _extension extension
+      remove_method :extension
+      def extension(*)
+      end
+    end
+  end
+  after(:all) do
+    class << Sequel
+      remove_method :extension
+      alias extension _extension
+      remove_method :_extension
+    end
+  end
+  before do
+    @ds = Sequel.mock.dataset
+  end
+
+  it "should have #extension! modify the receiver" do
+    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
+    @ds.extension!(:foo)
+    @ds.a.must_equal 1
+  end
+
+  it "should have #extension! return the receiver" do
+    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
+    @ds.extension!(:foo).must_be_same_as(@ds)
+  end
+end
+
+describe "Dataset#naked!" do
+  it "should remove any existing row_proc" do
+    d = Sequel.mock.dataset.with_row_proc(Proc.new{|r| r})
+    d.naked!.row_proc.must_be_nil
+    d.row_proc.must_be_nil
+  end
+end
+
+describe "Dataset#row_proc=" do
+  it "should set the row_proc" do
+    d = Sequel.mock.dataset.with_row_proc(Proc.new{|r| r})
+    d.row_proc.wont_be_nil
+    d.row_proc = nil
+    d.row_proc.must_be_nil
+  end
+end
+
+describe "Dataset#quote_identifiers=" do
+  it "should change quote identifiers setting" do
+    d = Sequel.mock.dataset.with_quote_identifiers(true)
+    d.literal(:a).must_equal '"a"'
+    d.quote_identifiers = false
+    d.literal(:a).must_equal 'a'
+  end
+end
+
+describe "Dataset#from_self!" do
+  it "should work" do
+    Sequel.mock.dataset.from(:test).select(:name).limit(1).from_self!.sql.must_equal 'SELECT * FROM (SELECT name FROM test LIMIT 1) AS t1'
+  end
+end
+
+describe "Sequel Mock Adapter" do
+  it "should be able to set the rows returned by each on a per dataset basis using _fetch" do
+    rs = []
+    db = Sequel.mock(:fetch=>{:a=>1})
+    ds = db[:t]
+    ds.each{|r| rs << r}
+    rs.must_equal [{:a=>1}]
+    ds._fetch = {:b=>2}
+    ds.each{|r| rs << r}
+    rs.must_equal [{:a=>1}, {:b=>2}]
+  end
+
+  it "should be able to set the number of rows modified by update and delete on a per dataset basis" do
+    db = Sequel.mock(:numrows=>2)
+    ds = db[:t]
+    ds.update(:a=>1).must_equal 2
+    ds.delete.must_equal 2
+    ds.numrows = 3
+    ds.update(:a=>1).must_equal 3
+    ds.delete.must_equal 3
+  end
+
+  it "should be able to set the autogenerated primary key returned by insert on a per dataset basis" do
+    db = Sequel.mock(:autoid=>1)
+    ds = db[:t]
+    ds.insert(:a=>1).must_equal 1
+    ds.autoid = 5
+    ds.insert(:a=>1).must_equal 5
+    ds.insert(:a=>1).must_equal 6
+    db[:t].insert(:a=>1).must_equal 2
+  end
+end
+
+end

data/spec/core/dataset_spec.rb

@@ -18,7 +18,7 @@ describe "Dataset" do
     d1.wont_equal @dataset
     d1.db.must_be_same_as(@dataset.db)
     d1.opts[:from].must_equal [:test]
-    @dataset.opts[:from].must_equal nil
+    @dataset.opts[:from].must_be_nil
     
     d2 = d1.clone(:order => [:name])
     d2.class.must_equal @dataset.class
@@ -27,7 +27,7 @@ describe "Dataset" do
     d2.db.must_be_same_as(@dataset.db)
     d2.opts[:from].must_equal [:test]
     d2.opts[:order].must_equal [:name]
-    d1.opts[:order].must_equal nil
+    d1.opts[:order].must_be_nil
   end
   
   it "should include Enumerable" do
@@ -35,96 +35,11 @@ describe "Dataset" do
   end
   
   it "should yield rows to each" do
-    ds = Sequel.mock[:t]
-    ds._fetch = {:x=>1}
+    ds = Sequel.mock[:t].with_fetch(:x=>1)
     called = false
     ds.each{|a| called = true; a.must_equal(:x=>1)}
     called.must_equal true
   end
-  
-  it "should get quote_identifiers default from database" do
-    db = Sequel::Database.new(:quote_identifiers=>true)
-    db[:a].quote_identifiers?.must_equal true
-    db = Sequel::Database.new(:quote_identifiers=>false)
-    db[:a].quote_identifiers?.must_equal false
-  end
-
-  it "should get identifier_input_method default from database" do
-    db = Sequel::Database.new(:identifier_input_method=>:upcase)
-    db[:a].identifier_input_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_input_method=>:downcase)
-    db[:a].identifier_input_method.must_equal :downcase
-  end
-
-  it "should get identifier_output_method default from database" do
-    db = Sequel::Database.new(:identifier_output_method=>:upcase)
-    db[:a].identifier_output_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_output_method=>:downcase)
-    db[:a].identifier_output_method.must_equal :downcase
-  end
-  
-  it "should have quote_identifiers= method which changes literalization of identifiers" do
-    @dataset.quote_identifiers = true
-    @dataset.literal(:a).must_equal '"a"'
-    @dataset.quote_identifiers = false
-    @dataset.literal(:a).must_equal 'a'
-  end
-  
-  it "should have identifier_input_method= method which changes literalization of identifiers" do
-    @dataset.identifier_input_method = :upcase
-    @dataset.literal(:a).must_equal 'A'
-    @dataset.identifier_input_method = :downcase
-    @dataset.literal(:A).must_equal 'a'
-    @dataset.identifier_input_method = :reverse
-    @dataset.literal(:at_b).must_equal 'b_ta'
-  end
-  
-  it "should have identifier_output_method= method which changes identifiers returned from the database" do
-    @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_C
-    @dataset.identifier_output_method = :upcase
-    @dataset.send(:output_identifier, "at_b_C").must_equal :AT_B_C
-    @dataset.identifier_output_method = :downcase
-    @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_c
-    @dataset.identifier_output_method = :reverse
-    @dataset.send(:output_identifier, "at_b_C").must_equal :C_b_ta
-  end
-  
-  it "should have with_quote_identifiers method which returns cloned dataset with changed literalization of identifiers" do
-    @dataset.with_quote_identifiers(true).literal(:a).must_equal '"a"'
-    @dataset.with_quote_identifiers(false).literal(:a).must_equal 'a'
-    ds = @dataset.freeze.with_quote_identifiers(false)
-    ds.literal(:a).must_equal 'a'
-    ds.frozen?.must_equal true
-  end
-  
-  it "should have with_identifier_input_method method which returns cloned dataset with changed literalization of identifiers" do
-    @dataset.with_identifier_input_method(:upcase).literal(:a).must_equal 'A'
-    @dataset.with_identifier_input_method(:downcase).literal(:A).must_equal 'a'
-    @dataset.with_identifier_input_method(:reverse).literal(:at_b).must_equal 'b_ta'
-    ds = @dataset.freeze.with_identifier_input_method(:reverse)
-    ds.frozen?.must_equal true
-    ds.literal(:at_b).must_equal 'b_ta'
-  end
-  
-  it "should have with_identifier_output_method method which returns cloned dataset with changed identifiers returned from the database" do
-    @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_C
-    @dataset.with_identifier_output_method(:upcase).send(:output_identifier, "at_b_C").must_equal :AT_B_C
-    @dataset.with_identifier_output_method(:downcase).send(:output_identifier, "at_b_C").must_equal :at_b_c
-    @dataset.with_identifier_output_method(:reverse).send(:output_identifier, "at_b_C").must_equal :C_b_ta
-    ds = @dataset.freeze.with_identifier_output_method(:reverse)
-    ds.send(:output_identifier, "at_b_C").must_equal :C_b_ta
-    ds.frozen?.must_equal true
-  end
-  
-  it "should have output_identifier handle empty identifiers" do
-    @dataset.send(:output_identifier, "").must_equal :untitled
-    @dataset.identifier_output_method = :upcase
-    @dataset.send(:output_identifier, "").must_equal :UNTITLED
-    @dataset.identifier_output_method = :downcase
-    @dataset.send(:output_identifier, "").must_equal :untitled
-    @dataset.identifier_output_method = :reverse
-    @dataset.send(:output_identifier, "").must_equal :deltitnu
-  end
 end
 
 describe "Dataset#clone" do
@@ -133,23 +48,16 @@ describe "Dataset#clone" do
   end
   
   it "should create an exact copy of the dataset" do
-    @dataset.row_proc = Proc.new{|r| r}
+    @dataset = @dataset.with_row_proc(Proc.new{|r| r})
     clone = @dataset.clone
 
     clone.object_id.wont_equal @dataset.object_id
     clone.class.must_equal @dataset.class
     clone.db.must_equal @dataset.db
     clone.opts.must_equal @dataset.opts
-    clone.row_proc.must_equal @dataset.row_proc
   end
   
   it "should copy the dataset opts" do
-    clone = @dataset.clone
-
-    clone.opts.must_equal @dataset.opts
-    @dataset.filter!(:a => 'b')
-    clone.opts[:filter].must_equal nil
-
     clone = @dataset.clone(:from => [:other])
     @dataset.opts[:from].must_equal [:items]
     clone.opts[:from].must_equal [:other]
@@ -169,8 +77,7 @@ describe "Dataset#clone" do
     m = Module.new do
       def __xyz__; "xyz"; end
     end
-    @dataset.extend(m)
-    @dataset.clone({}).must_respond_to(:__xyz__)
+    @dataset.with_extend(m).clone({}).must_respond_to(:__xyz__)
   end
 end
 
@@ -242,8 +149,7 @@ describe "A simple dataset" do
   end
   
   it "should format a truncate statement with multiple tables if supported" do
-    meta_def(@dataset, :check_truncation_allowed!){}
-    @dataset.from(:test, :test2).truncate_sql.must_equal 'TRUNCATE TABLE test, test2'
+    @dataset.with_extend{def check_truncation_allowed!; end}.from(:test, :test2).truncate_sql.must_equal 'TRUNCATE TABLE test, test2'
   end
   
   it "should format an insert statement with default values" do
@@ -251,9 +157,10 @@ describe "A simple dataset" do
   end
   
   it "should use a single column with a default value when the dataset doesn't support using insert statement with default values" do
-    meta_def(@dataset, :insert_supports_empty_values?){false}
-    meta_def(@dataset, :columns){[:a, :b]}
-    @dataset.insert_sql.must_equal 'INSERT INTO test (b) VALUES (DEFAULT)'
+    @dataset.with_extend do
+      def insert_supports_empty_values?; false end
+      def columns; [:a, :b] end
+    end.insert_sql.must_equal 'INSERT INTO test (b) VALUES (DEFAULT)'
   end
   
   it "should format an insert statement with hash" do
@@ -521,7 +428,7 @@ describe "Dataset#where" do
   end
 
   it "should handle IN/NOT IN queries with multiple columns and an array where the database doesn't support it" do
-    meta_def(@dataset, :supports_multiple_column_in?){false}
+    @dataset = @dataset.with_extend{def supports_multiple_column_in?; false end}
     @dataset.filter([:id1, :id2] => [[1, 2], [3,4]]).sql.must_equal "SELECT * FROM test WHERE (((id1 = 1) AND (id2 = 2)) OR ((id1 = 3) AND (id2 = 4)))"
     @dataset.exclude([:id1, :id2] => [[1, 2], [3,4]]).sql.must_equal "SELECT * FROM test WHERE (((id1 != 1) OR (id2 != 2)) AND ((id1 != 3) OR (id2 != 4)))"
     @dataset.filter([:id1, :id2] => Sequel.value_list([[1, 2], [3,4]])).sql.must_equal "SELECT * FROM test WHERE (((id1 = 1) AND (id2 = 2)) OR ((id1 = 3) AND (id2 = 4)))"
@@ -529,7 +436,7 @@ describe "Dataset#where" do
   end
 
   it "should handle IN/NOT IN queries with multiple columns and a dataset where the database doesn't support it" do
-    meta_def(@dataset, :supports_multiple_column_in?){false}
+    @dataset = @dataset.with_extend{def supports_multiple_column_in?; false end}
     db = Sequel.mock(:fetch=>[{:id1=>1, :id2=>2}, {:id1=>3, :id2=>4}])
     d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2)
     @dataset.filter([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE (((id1 = 1) AND (id2 = 2)) OR ((id1 = 3) AND (id2 = 4)))"
@@ -539,7 +446,7 @@ describe "Dataset#where" do
   end
   
   it "should handle IN/NOT IN queries with multiple columns and an empty dataset where the database doesn't support it" do
-    meta_def(@dataset, :supports_multiple_column_in?){false}
+    @dataset = @dataset.with_extend{def supports_multiple_column_in?; false end}
     db = Sequel.mock
     d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2)
     @dataset.filter([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE (1 = 0)"
@@ -549,10 +456,9 @@ describe "Dataset#where" do
   end
   
   it "should handle IN/NOT IN queries for datasets with row_procs" do
-    meta_def(@dataset, :supports_multiple_column_in?){false}
+    @dataset = @dataset.with_extend{def supports_multiple_column_in?; false end}
     db = Sequel.mock(:fetch=>[{:id1=>1, :id2=>2}, {:id1=>3, :id2=>4}])
-    d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2)
-    d1.row_proc = proc{|h| Object.new}
+    d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2).with_row_proc(proc{|h| Object.new})
     @dataset.filter([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE (((id1 = 1) AND (id2 = 2)) OR ((id1 = 3) AND (id2 = 4)))"
     db.sqls.must_equal ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
     @dataset.exclude([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE (((id1 != 1) OR (id2 != 2)) AND ((id1 != 3) OR (id2 != 4)))"
@@ -585,7 +491,7 @@ describe "Dataset#where" do
   end
 
   it "should use boolean expression if dataset does not support where true/false" do
-    def @dataset.supports_where_true?() false end
+    @dataset = @dataset.with_extend{def supports_where_true?() false end}
     @dataset.filter(true).sql.must_equal "SELECT * FROM test WHERE (1 = 1)"
     @dataset.filter(Sequel::SQLTRUE).sql.must_equal "SELECT * FROM test WHERE (1 = 1)"
     @dataset.filter(false).sql.must_equal "SELECT * FROM test WHERE (1 = 0)"
@@ -771,7 +677,9 @@ describe "Dataset#invert" do
   end
 
   it "should return a dataset that selects no rows if dataset is not filtered" do
-    @d.invert.sql.must_equal "SELECT * FROM test WHERE 'f'"
+    3.times do
+      @d.invert.sql.must_equal "SELECT * FROM test WHERE 'f'"
+    end
   end
 
   it "should invert current filter if dataset is filtered" do
@@ -877,25 +785,25 @@ describe "Dataset#group_by" do
   end
 
   it "should support a #group_rollup method if the database supports it" do
-    meta_def(@dataset, :supports_group_rollup?){true}
+    @dataset = @dataset.with_extend{def supports_group_rollup?; true end}
     @dataset.group(:type_id).group_rollup.select_sql.must_equal "SELECT * FROM test GROUP BY ROLLUP(type_id)"
     @dataset.group(:type_id, :b).group_rollup.select_sql.must_equal "SELECT * FROM test GROUP BY ROLLUP(type_id, b)"
-    meta_def(@dataset, :uses_with_rollup?){true}
+    @dataset = @dataset.with_extend{def uses_with_rollup?; true end}
     @dataset.group(:type_id).group_rollup.select_sql.must_equal "SELECT * FROM test GROUP BY type_id WITH ROLLUP"
     @dataset.group(:type_id, :b).group_rollup.select_sql.must_equal "SELECT * FROM test GROUP BY type_id, b WITH ROLLUP"
   end
 
   it "should support a #group_cube method if the database supports it" do
-    meta_def(@dataset, :supports_group_cube?){true}
+    @dataset = @dataset.with_extend{def supports_group_cube?; true end}
     @dataset.group(:type_id).group_cube.select_sql.must_equal "SELECT * FROM test GROUP BY CUBE(type_id)"
     @dataset.group(:type_id, :b).group_cube.select_sql.must_equal "SELECT * FROM test GROUP BY CUBE(type_id, b)"
-    meta_def(@dataset, :uses_with_rollup?){true}
+    @dataset = @dataset.with_extend{def uses_with_rollup?; true end}
     @dataset.group(:type_id).group_cube.select_sql.must_equal "SELECT * FROM test GROUP BY type_id WITH CUBE"
     @dataset.group(:type_id, :b).group_cube.select_sql.must_equal "SELECT * FROM test GROUP BY type_id, b WITH CUBE"
   end
 
   it "should support a #grouping_sets method if the database supports it" do
-    meta_def(@dataset, :supports_grouping_sets?){true}
+    @dataset = @dataset.with_extend{def supports_grouping_sets?; true end}
     @dataset.group(:type_id).grouping_sets.select_sql.must_equal "SELECT * FROM test GROUP BY GROUPING SETS((type_id))"
     @dataset.group([:type_id, :b], :type_id, []).grouping_sets.select_sql.must_equal "SELECT * FROM test GROUP BY GROUPING SETS((type_id, b), (type_id), ())"
   end
@@ -936,7 +844,7 @@ end
 
 describe "Dataset#literal" do
   before do
-    @ds = Sequel::Database.new.dataset
+    @ds = Sequel.mock.dataset
   end
   
   it "should convert qualified symbol notation into dot notation" do
@@ -972,7 +880,7 @@ end
 
 describe "Dataset#literal" do
   before do
-    @dataset = Sequel::Database.new.from(:test)
+    @dataset = Sequel.mock[:test]
   end
   
   it "should escape strings properly" do
@@ -1019,10 +927,7 @@ describe "Dataset#literal" do
         "not called #{ds.blah}"
       end
     end
-    def @dataset.blah
-      "ds"
-    end
-    @dataset.literal(@a.new).must_equal "called ds"
+    @dataset.with_extend{def blah; "ds" end}.literal(@a.new).must_equal "called ds"
   end
   
   it "should call sql_literal with dataset on type if not natively supported and the object responds to it" do
@@ -1031,10 +936,7 @@ describe "Dataset#literal" do
         "called #{ds.blah}"
       end
     end
-    def @dataset.blah
-      "ds"
-    end
-    @dataset.literal(@a.new).must_equal "called ds"
+    @dataset.with_extend{def blah; "ds" end}.literal(@a.new).must_equal "called ds"
   end
   
   it "should literalize datasets as subqueries" do
@@ -1049,7 +951,7 @@ describe "Dataset#literal" do
   end
   
   it "should literalize times properly for databases supporting millisecond precision" do
-    meta_def(@dataset, :timestamp_precision){3}
+    @dataset = @dataset.with_extend{def timestamp_precision; 3 end}
     @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 500000)).must_equal "'01:02:03.500'"
     @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5, 500000)).must_equal "'2010-01-02 03:04:05.500'"
     @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).must_equal "'2010-01-02 03:04:05.500'"
@@ -1069,18 +971,18 @@ describe "Dataset#literal" do
   end
 
   it "should literalize Time, DateTime, Date properly if SQL standard format is required" do
-    meta_def(@dataset, :requires_sql_standard_datetimes?){true}
+    @dataset = @dataset.with_extend{def requires_sql_standard_datetimes?; true end}
     @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5, 500000)).must_equal "TIMESTAMP '2010-01-02 03:04:05.500000'"
     @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).must_equal "TIMESTAMP '2010-01-02 03:04:05.500000'"
     @dataset.literal(Date.new(2010, 1, 2)).must_equal "DATE '2010-01-02'"
   end
   
   it "should literalize Time and DateTime properly if the database support timezones in timestamps" do
-    meta_def(@dataset, :supports_timestamp_timezones?){true}
+    @dataset = @dataset.with_extend{def supports_timestamp_timezones?; true end}
     @dataset.literal(Time.utc(2010, 1, 2, 3, 4, 5, 500000)).must_equal "'2010-01-02 03:04:05.500000+0000'"
     @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).must_equal "'2010-01-02 03:04:05.500000+0000'"
 
-    meta_def(@dataset, :supports_timestamp_usecs?){false}
+    @dataset = @dataset.with_extend{def supports_timestamp_usecs?; false end}
     @dataset.literal(Time.utc(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05+0000'"
     @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05+0000'"
   end
@@ -1171,7 +1073,7 @@ describe "Dataset#from" do
   end
 
   it "should automatically use a default from table if no from table is present" do
-    def @dataset.empty_from_sql; ' FROM DEFFROM'; end
+    @dataset = @dataset.with_extend{def empty_from_sql; ' FROM DEFFROM'; end}
     @dataset.select_sql.must_equal "SELECT * FROM DEFFROM"
   end
 
@@ -1192,8 +1094,10 @@ describe "Dataset#from" do
   end
 
   it "should hoist WITH clauses from subqueries if the dataset doesn't support CTEs in subselects" do
-    meta_def(@dataset, :supports_cte?){true}
-    meta_def(@dataset, :supports_cte_in_subselect?){false}
+    @dataset = @dataset.with_extend do
+      def supports_cte?; true end
+      def supports_cte_in_subselect?; false end
+    end
     @dataset.from(@dataset.from(:a).with(:a, @dataset.from(:b))).sql.must_equal 'WITH a AS (SELECT * FROM b) SELECT * FROM (SELECT * FROM a) AS t1'
     @dataset.from(@dataset.from(:a).with(:a, @dataset.from(:b)), @dataset.from(:c).with(:c, @dataset.from(:d))).sql.must_equal 'WITH a AS (SELECT * FROM b), c AS (SELECT * FROM d) SELECT * FROM (SELECT * FROM a) AS t1, (SELECT * FROM c) AS t2'
   end
@@ -1238,8 +1142,8 @@ describe "Dataset#select" do
   end
 
   it "should override the previous select option" do
-    @d.select!(:a, :b, :c).select.sql.must_equal 'SELECT * FROM test'
-    @d.select!(:price).select(:name).sql.must_equal 'SELECT name FROM test'
+    @d.select(:a, :b, :c).select.sql.must_equal 'SELECT * FROM test'
+    @d.select(:price).select(:name).sql.must_equal 'SELECT name FROM test'
   end
   
   it "should accept arbitrary objects and literalize them correctly" do
@@ -1294,7 +1198,7 @@ describe "Dataset#select_all" do
   end
   
   it "should override the previous select option" do
-    @d.select!(:a, :b, :c).select_all.sql.must_equal 'SELECT * FROM test'
+    @d.select(:a, :b, :c).select_all.sql.must_equal 'SELECT * FROM test'
   end
 
   it "should select all columns in a table if given an argument" do
@@ -1376,7 +1280,7 @@ describe "Dataset#select_append" do
   end
 
   it "should select from all from and join tables if SELECT *, column not supported" do
-    meta_def(@d, :supports_select_all_and_column?){false}
+    @d = @d.with_extend{def supports_select_all_and_column?; false end}
     @d.select_append(:b).sql.must_equal 'SELECT test.*, b FROM test'
     @d.from(:test, :c).select_append(:b).sql.must_equal 'SELECT test.*, c.*, b FROM test, c'
     @d.cross_join(:c).select_append(:b).sql.must_equal 'SELECT test.*, c.*, b FROM test CROSS JOIN c'
@@ -1434,25 +1338,37 @@ end
 
 describe "Dataset#unfiltered" do
   it "should remove filtering from the dataset" do
-    Sequel.mock.dataset.from(:test).filter(:score=>1).unfiltered.sql.must_equal 'SELECT * FROM test'
+    ds = Sequel.mock.dataset.from(:test).filter(:score=>1)
+    3.times do
+      ds.unfiltered.sql.must_equal 'SELECT * FROM test'
+    end
   end
 end
 
 describe "Dataset#unlimited" do
   it "should remove limit and offset from the dataset" do
-    Sequel.mock.dataset.from(:test).limit(1, 2).unlimited.sql.must_equal 'SELECT * FROM test'
+    ds = Sequel.mock.dataset.from(:test).limit(1, 2)
+    3.times do
+      ds.unlimited.sql.must_equal 'SELECT * FROM test'
+    end
   end
 end
 
 describe "Dataset#ungrouped" do
   it "should remove group and having clauses from the dataset" do
-    Sequel.mock.dataset.from(:test).group(:a).having(:b).ungrouped.sql.must_equal 'SELECT * FROM test'
+    ds = Sequel.mock.dataset.from(:test).group(:a).having(:b)
+    3.times do
+      ds.ungrouped.sql.must_equal 'SELECT * FROM test'
+    end
   end
 end
 
 describe "Dataset#unordered" do
   it "should remove ordering from the dataset" do
-    Sequel.mock.dataset.from(:test).order(:name).unordered.sql.must_equal 'SELECT * FROM test'
+    ds = Sequel.mock.dataset.from(:test).order(:name)
+    3.times do
+      ds.unordered.sql.must_equal 'SELECT * FROM test'
+    end
   end
 end
 
@@ -1474,7 +1390,9 @@ describe "Dataset#with_sql" do
   end
 
   it "should keep row_proc" do
-    @dataset.with_sql('SELECT 1 FROM test').row_proc.must_equal @dataset.row_proc
+    @dataset.with_sql('SELECT 1 FROM test').row_proc.must_be_nil
+    p = lambda{}
+    @dataset.with_row_proc(p).with_sql('SELECT 1 FROM test').row_proc.must_equal p
   end
 
   it "should work with method symbols and arguments" do
@@ -1553,42 +1471,46 @@ describe "Dataset#order_prepend" do
   end
 end
 
-describe "Dataset#reverse_order" do
+describe "Dataset#reverse" do
   before do
     @dataset = Sequel.mock.dataset.from(:test)
   end
   
   it "should use DESC as default order" do
-    @dataset.reverse_order(:name).sql.must_equal 'SELECT * FROM test ORDER BY name DESC'
+    @dataset.reverse(:name).sql.must_equal 'SELECT * FROM test ORDER BY name DESC'
   end
   
   it "should invert the order given" do
-    @dataset.reverse_order(Sequel.desc(:name)).sql.must_equal 'SELECT * FROM test ORDER BY name ASC'
+    @dataset.reverse(Sequel.desc(:name)).sql.must_equal 'SELECT * FROM test ORDER BY name ASC'
   end
   
   it "should invert the order for ASC expressions" do
-    @dataset.reverse_order(Sequel.asc(:name)).sql.must_equal 'SELECT * FROM test ORDER BY name DESC'
+    @dataset.reverse(Sequel.asc(:name)).sql.must_equal 'SELECT * FROM test ORDER BY name DESC'
   end
   
   it "should accept multiple arguments" do
-    @dataset.reverse_order(:name, Sequel.desc(:price)).sql.must_equal 'SELECT * FROM test ORDER BY name DESC, price ASC'
+    @dataset.reverse(:name, Sequel.desc(:price)).sql.must_equal 'SELECT * FROM test ORDER BY name DESC, price ASC'
   end
 
   it "should handles NULLS ordering correctly when reversing" do
-    @dataset.reverse_order(Sequel.asc(:name, :nulls=>:first), Sequel.desc(:price, :nulls=>:last)).sql.must_equal 'SELECT * FROM test ORDER BY name DESC NULLS LAST, price ASC NULLS FIRST'
+    @dataset.reverse(Sequel.asc(:name, :nulls=>:first), Sequel.desc(:price, :nulls=>:last)).sql.must_equal 'SELECT * FROM test ORDER BY name DESC NULLS LAST, price ASC NULLS FIRST'
   end
 
   it "should reverse a previous ordering if no arguments are given" do
-    @dataset.order(:name).reverse_order.sql.must_equal 'SELECT * FROM test ORDER BY name DESC'
-    @dataset.order(Sequel.desc(:clumsy), :fool).reverse_order.sql.must_equal 'SELECT * FROM test ORDER BY clumsy ASC, fool DESC'
+    ds1 = @dataset.order(:name)
+    ds2 = @dataset.order(Sequel.desc(:clumsy), :fool)
+    3.times do
+      ds1.reverse.sql.must_equal 'SELECT * FROM test ORDER BY name DESC'
+      ds2.reverse.sql.must_equal 'SELECT * FROM test ORDER BY clumsy ASC, fool DESC'
+    end
   end
   
   it "should return an unordered dataset for a dataset with no order" do
-    @dataset.unordered.reverse_order.sql.must_equal 'SELECT * FROM test'
+    @dataset.unordered.reverse.sql.must_equal 'SELECT * FROM test'
   end
   
-  it "should have #reverse alias" do
-    @dataset.order(:name).reverse.sql.must_equal 'SELECT * FROM test ORDER BY name DESC'
+  it "should have #reverse_order alias" do
+    @dataset.order(:name).reverse_order.sql.must_equal 'SELECT * FROM test ORDER BY name DESC'
   end
 
   it "should accept a block" do
@@ -1638,8 +1560,7 @@ describe "Dataset#limit" do
   end
   
   it "should work with fixed sql datasets" do
-    @dataset.opts[:sql] = 'select * from cccc'
-    @dataset.limit(6, 10).sql.must_equal 'SELECT * FROM (select * from cccc) AS t1 LIMIT 6 OFFSET 10'
+    @dataset.with_sql('select * from cccc').limit(6, 10).sql.must_equal 'SELECT * FROM (select * from cccc) AS t1 LIMIT 6 OFFSET 10'
   end
   
   it "should raise an error if an invalid limit or offset is used" do
@@ -1698,14 +1619,18 @@ end
 describe "Dataset#with_extend" do
   it "should returned clone dataset extended with given modules" do
     d = Sequel.mock.dataset
-    m1 = Module.new{def a; 1; end}
-    m2 = Module.new{def b; a+2; end}
-    d.with_extend(m1, m2).b.must_equal 3
-    d.respond_to?(:b).must_equal false
-    ds = d.freeze.with_extend(m1, m2)
-    ds.b.must_equal 3
+    m1 = Module.new{def a; 2**super end}
+    m2 = Module.new{def a; 3 end}
+    d.with_extend(m1, m2){def a; 4**super end}.a.must_equal 65536
+    d.respond_to?(:a).must_equal false
+    ds = d.freeze.with_extend(m1, m2){def a; 4**super end}
+    ds.a.must_equal 65536
     ds.frozen?.must_equal true
   end
+
+  it "should work with just a block" do
+    Sequel.mock.dataset.with_extend{def a; 1 end}.a.must_equal 1
+  end
 end
 
 describe "Dataset#with_row_proc" do
@@ -1713,7 +1638,7 @@ describe "Dataset#with_row_proc" do
     d = Sequel.mock.dataset
     l = lambda{|r| r}
     d.with_row_proc(l).row_proc.must_equal l
-    assert_equal nil, d.row_proc
+    d.row_proc.must_be_nil
     ds = d.freeze.with_row_proc(l)
     ds.frozen?.must_equal true
     ds.row_proc.must_equal l
@@ -1722,19 +1647,9 @@ end
 
 describe "Dataset#naked" do
   it "should returned clone dataset without row_proc" do
-    d = Sequel.mock.dataset
-    d.row_proc = Proc.new{|r| r}
-    d.naked.row_proc.must_equal nil
-    refute_equal nil, d.row_proc
-  end
-end
-
-describe "Dataset#naked!" do
-  it "should remove any existing row_proc" do
-    d = Sequel.mock.dataset
-    d.row_proc = Proc.new{|r| r}
-    d.naked!.row_proc.must_equal nil
-    d.row_proc.must_equal nil
+    d = Sequel.mock.dataset.with_row_proc(Proc.new{|r| r})
+    d.naked.row_proc.must_be_nil
+    d.row_proc.wont_be_nil
   end
 end
 
@@ -1780,13 +1695,13 @@ describe "Dataset#map" do
   end
   
   it "should not call the row_proc if an argument is given" do
-    @d.row_proc = proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h}
+    @d = @d.with_row_proc(proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h})
     @d.map(:a).must_equal [1, 3, 5]
     @d.map([:a, :b]).must_equal [[1, 2], [3, 4], [5, 6]]
   end
 
   it "should call the row_proc if no argument is given" do
-    @d.row_proc = proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h}
+    @d = @d.with_row_proc(proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h})
     @d.map{|n| n[:a] + n[:b]}.must_equal [6, 14, 22]
   end
   
@@ -1822,7 +1737,7 @@ describe "Dataset#to_hash" do
   end
 
   it "should not call the row_proc if two arguments are given" do
-    @d.row_proc = proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h}
+    @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)
@@ -1831,21 +1746,21 @@ describe "Dataset#to_hash" do
   end
 
   it "should call the row_proc if only a single argument is given" do
-    @d.row_proc = proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h}
+    @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})
   end
 
   it "should handle a single composite key when using a row_proc" do
-    c = @d.row_proc = Class.new do
+    c = Class.new do
       def self.call(h); new(h); end
       def initialize(h); @h = h; end
       def [](k) @h[k]; end
       def h; @h; end
       def ==(o) @h == o.h; end
     end
-    @d.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).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))
   end
 end
 
@@ -1877,13 +1792,12 @@ describe "Dataset#to_hash_groups" do
 
   it "should accept an :all option to use all into which entries can be merged" do
     called = false
-    meta_def(@d, :post_load){|_| called = true}
-    @d.to_hash_groups(:a, :b, :all=>true)
+    @d.with_extend{define_method(:post_load){|_| called = true}}.to_hash_groups(:a, :b, :all=>true)
     called.must_equal true
   end
 
   it "should not call the row_proc if two arguments are given" do
-    @d.row_proc = proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h}
+    @d = @d.with_row_proc(proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h})
     @d.to_hash_groups(:a, :b).must_equal(1 => [2, 6], 3 => [4], 7 => [4])
     @d.to_hash_groups(:b, :a).must_equal(2 => [1], 4=>[3, 7], 6=>[1])
     @d.to_hash_groups([:a, :b], :b).must_equal([1, 2] => [2], [3, 4] => [4], [1, 6] => [6], [7, 4]=>[4])
@@ -1892,21 +1806,21 @@ describe "Dataset#to_hash_groups" do
   end
 
   it "should call the row_proc if only a single argument is given" do
-    @d.row_proc = proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h}
+    @d = @d.with_row_proc(proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h})
     @d.to_hash_groups(:a).must_equal(2 => [{:a => 2, :b => 4}, {:a => 2, :b => 12}], 6 => [{:a => 6, :b => 8}], 14 => [{:a => 14, :b => 8}])
     @d.to_hash_groups(:b).must_equal(4 => [{:a => 2, :b => 4}], 8 => [{:a => 6, :b => 8}, {:a => 14, :b => 8}], 12 => [{:a => 2, :b => 12}])
     @d.to_hash_groups([:a, :b]).must_equal([2, 4] => [{:a => 2, :b => 4}], [6, 8] => [{:a => 6, :b => 8}], [2, 12] => [{:a => 2, :b => 12}], [14, 8] => [{:a => 14, :b => 8}])
   end
 
   it "should handle a single composite key when using a row_proc" do
-    c = @d.row_proc = Class.new do
+    c = Class.new do
       def self.call(h); new(h); end
       def initialize(h); @h = h; end
       def [](k) @h[k]; end
       def h; @h; end
       def ==(o) @h == o.h; end
     end
-    @d.to_hash_groups([:a, :b]).must_equal([1, 2] => [c.call(:a => 1, :b => 2)], [3, 4] => [c.call(:a => 3, :b => 4)], [1, 6] => [c.call(:a => 1, :b => 6)], [7, 4] => [c.call(:a => 7, :b => 4)])
+    @d.with_row_proc(c).to_hash_groups([:a, :b]).must_equal([1, 2] => [c.call(:a => 1, :b => 2)], [3, 4] => [c.call(:a => 3, :b => 4)], [1, 6] => [c.call(:a => 1, :b => 6)], [7, 4] => [c.call(:a => 7, :b => 4)])
   end
 end
 
@@ -1926,13 +1840,13 @@ describe "Dataset#distinct" do
   end
   
   it "should use DISTINCT ON if columns are given and DISTINCT ON is supported" do
-    meta_def(@dataset, :supports_distinct_on?){true}
+    @dataset = @dataset.with_extend{def supports_distinct_on?; true end}
     @dataset.distinct(:a, :b).sql.must_equal 'SELECT DISTINCT ON (a, b) name FROM test'
     @dataset.distinct(Sequel.cast(:stamp, :integer), :node_id=>nil).sql.must_equal 'SELECT DISTINCT ON (CAST(stamp AS integer), (node_id IS NULL)) name FROM test'
   end
 
   it "should use DISTINCT ON if columns are given in a virtual row block and DISTINCT ON is supported" do
-    meta_def(@dataset, :supports_distinct_on?){true}
+    @dataset = @dataset.with_extend{def supports_distinct_on?; true end}
     @dataset.distinct{func(:id)}.sql.must_equal 'SELECT DISTINCT ON (func(id)) name FROM test'
   end
 
@@ -1945,27 +1859,35 @@ end
 describe "Dataset#count" do
   before do
     @db = Sequel.mock(:fetch=>{:count=>1})
-    @dataset = @db.from(:test).columns(:count)
+    @dataset = @db.from(:test).columns(:count).freeze
   end
   
   it "should format SQL properly" do
-    @dataset.count.must_equal 1
-    @db.sqls.must_equal ['SELECT count(*) AS count FROM test LIMIT 1']
+    5.times do
+      @dataset.count.must_equal 1
+      @db.sqls.must_equal ['SELECT count(*) AS count FROM test LIMIT 1']
+    end
   end
   
   it "should accept an argument" do
-    @dataset.count(:foo).must_equal 1
-    @db.sqls.must_equal ['SELECT count(foo) AS count FROM test LIMIT 1']
+    5.times do
+      @dataset.count(:foo).must_equal 1
+      @db.sqls.must_equal ['SELECT count(foo) AS count FROM test LIMIT 1']
+    end
   end
   
   it "should work with a nil argument" do
-    @dataset.count(nil).must_equal 1
-    @db.sqls.must_equal ['SELECT count(NULL) AS count FROM test LIMIT 1']
+    5.times do
+      @dataset.count(nil).must_equal 1
+      @db.sqls.must_equal ['SELECT count(NULL) AS count FROM test LIMIT 1']
+    end
   end
   
   it "should accept a virtual row block" do
-    @dataset.count{foo(bar)}.must_equal 1
-    @db.sqls.must_equal ['SELECT count(foo(bar)) AS count FROM test LIMIT 1']
+    5.times do 
+      @dataset.count{foo(bar)}.must_equal 1
+      @db.sqls.must_equal ['SELECT count(foo(bar)) AS count FROM test LIMIT 1']
+    end
   end
   
   it "should raise an Error if given an argument and a block" do
@@ -1978,8 +1900,7 @@ describe "Dataset#count" do
   end
   
   it "should count properly for datasets with fixed sql" do
-    @dataset.opts[:sql] = "select abc from xyz"
-    @dataset.count.must_equal 1
+    @dataset.with_sql("select abc from xyz").count.must_equal 1
     @db.sqls.must_equal ["SELECT count(*) AS count FROM (select abc from xyz) AS t1 LIMIT 1"]
   end
 
@@ -2003,9 +1924,7 @@ describe "Dataset#count" do
   end
   
   it "should work on a graphed_dataset" do
-    def @dataset.columns
-      [:a]
-    end
+    ds = @dataset.with_extend{ def columns; [:a] end}
     @dataset.graph(@dataset, [:a], :table_alias=>:test2).count.must_equal 1
     @db.sqls.must_equal ['SELECT count(*) AS count FROM test LEFT OUTER JOIN test AS test2 USING (a) LIMIT 1']
   end
@@ -2161,16 +2080,13 @@ describe "Dataset#from_self" do
 
   it "should hoist WITH clauses in current dataset if dataset doesn't support WITH in subselect" do
     ds = Sequel.mock.dataset
-    meta_def(ds, :supports_cte?){true}
-    meta_def(ds, :supports_cte_in_subselect?){false}
+    ds = ds.with_extend do
+      def supports_cte?; true end
+      def supports_cte_in_subselect?; false end
+    end
     ds.from(:a).with(:a, ds.from(:b)).from_self.sql.must_equal 'WITH a AS (SELECT * FROM b) SELECT * FROM (SELECT * FROM a) AS t1'
     ds.from(:a, :c).with(:a, ds.from(:b)).with(:c, ds.from(:d)).from_self.sql.must_equal 'WITH a AS (SELECT * FROM b), c AS (SELECT * FROM d) SELECT * FROM (SELECT * FROM a, c) AS t1'
   end
-
-  it "should have working mutation method" do
-    @ds.from_self!
-    @ds.sql.must_equal 'SELECT * FROM (SELECT name FROM test LIMIT 1) AS t1'
-  end
 end
 
 describe "Dataset#join_table" do
@@ -2295,7 +2211,7 @@ describe "Dataset#join_table" do
   end
   
   it "should default :qualify option to default_join_table_qualification" do
-    def @d.default_join_table_qualification; false; end
+    @d = @d.with_extend{def default_join_table_qualification; false end}
     @d.from('stats').join(:players, :id => :player_id).sql.must_equal 'SELECT * FROM "stats" INNER JOIN "players" ON ("id" = "player_id")'
   end
   
@@ -2325,7 +2241,7 @@ describe "Dataset#join_table" do
   it "should support joining datasets" do
     ds = Sequel.mock.dataset.from(:categories)
     @d.join_table(:left_outer, ds, :item_id => :id).sql.must_equal 'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) AS "t1" ON ("t1"."item_id" = "items"."id")'
-    ds.filter!(:active => true)
+    ds = ds.where(:active => true)
     @d.join_table(:left_outer, ds, :item_id => :id).sql.must_equal 'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories WHERE (active IS TRUE)) AS "t1" ON ("t1"."item_id" = "items"."id")'
     @d.from_self.join_table(:left_outer, ds, :item_id => :id).sql.must_equal 'SELECT * FROM (SELECT * FROM "items") AS "t1" LEFT OUTER JOIN (SELECT * FROM categories WHERE (active IS TRUE)) AS "t2" ON ("t2"."item_id" = "t1"."id")'
   end
@@ -2370,16 +2286,17 @@ describe "Dataset#join_table" do
   end
 
   it "should emulate JOIN USING (poorly) if the dataset doesn't support it" do
-    meta_def(@d, :supports_join_using?){false}
+    @d = @d.with_extend{def supports_join_using?; false end}
     @d.join(:categories, [:id]).sql.must_equal 'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."id" = "items"."id")'
   end
 
   it "should hoist WITH clauses from subqueries if the dataset doesn't support CTEs in subselects" do
-    meta_def(@d, :supports_cte?){true}
-    meta_def(@d, :supports_cte_in_subselect?){false}
+    @d = @d.with_extend do
+      def supports_cte?; true end
+      def supports_cte_in_subselect?; false end
+    end
     ds = Sequel.mock.dataset.from(:categories)
-    meta_def(ds, :supports_cte?){true}
-    @d.join(ds.with(:a, Sequel.mock.dataset.from(:b)), [:id]).sql.must_equal 'WITH "a" AS (SELECT * FROM b) SELECT * FROM "items" INNER JOIN (SELECT * FROM categories) AS "t1" USING ("id")'
+    @d.join(ds.with_extend{def supports_cte?; true end}.with(:a, Sequel.mock.dataset.from(:b)), [:id]).sql.must_equal 'WITH "a" AS (SELECT * FROM b) SELECT * FROM "items" INNER JOIN (SELECT * FROM categories) AS "t1" USING ("id")'
   end
 
   it "should raise an error if using an array of symbols with a block" do
@@ -2461,61 +2378,79 @@ end
 
 describe "Dataset aggregate methods" do
   before do
-    @d = Sequel.mock(:fetch=>proc{|s| {1=>s}})[:test]
+    @d = Sequel.mock(:fetch=>proc{|s| {1=>s}})[:test].freeze
   end
   
   it "should include min" do
-    @d.min(:a).must_equal 'SELECT min(a) AS min FROM test LIMIT 1'
+    5.times do
+      @d.min(:a).must_equal 'SELECT min(a) AS min FROM test LIMIT 1'
+    end
   end
   
   it "should include max" do
-    @d.max(:b).must_equal 'SELECT max(b) AS max FROM test LIMIT 1'
+    5.times do
+      @d.max(:b).must_equal 'SELECT max(b) AS max FROM test LIMIT 1'
+    end
   end
   
   it "should include sum" do
-    @d.sum(:c).must_equal 'SELECT sum(c) AS sum FROM test LIMIT 1'
+    5.times do
+      @d.sum(:c).must_equal 'SELECT sum(c) AS sum FROM test LIMIT 1'
+    end
   end
   
   it "should include avg" do
-    @d.avg(:d).must_equal 'SELECT avg(d) AS avg FROM test LIMIT 1'
+    5.times do
+      @d.avg(:d).must_equal 'SELECT avg(d) AS avg FROM test LIMIT 1'
+    end
   end
   
   it "should accept qualified columns" do
-    @d.avg(:test__bc).must_equal 'SELECT avg(test.bc) AS avg FROM test LIMIT 1'
+    5.times do
+      @d.avg(:test__bc).must_equal 'SELECT avg(test.bc) AS avg FROM test LIMIT 1'
+    end
   end
   
   it "should use a subselect for the same conditions as count" do
     d = @d.order(:a).limit(5)
-    d.avg(:a).must_equal 'SELECT avg(a) AS avg FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
-    d.sum(:a).must_equal 'SELECT sum(a) AS sum FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
-    d.min(:a).must_equal 'SELECT min(a) AS min FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
-    d.max(:a).must_equal 'SELECT max(a) AS max FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
+    5.times do
+      d.avg(:a).must_equal 'SELECT avg(a) AS avg FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
+      d.sum(:a).must_equal 'SELECT sum(a) AS sum FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
+      d.min(:a).must_equal 'SELECT min(a) AS min FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
+      d.max(:a).must_equal 'SELECT max(a) AS max FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
+    end
   end
   
   it "should accept virtual row blocks" do
-    @d.avg{a(b)}.must_equal 'SELECT avg(a(b)) AS avg FROM test LIMIT 1'
-    @d.sum{a(b)}.must_equal 'SELECT sum(a(b)) AS sum FROM test LIMIT 1'
-    @d.min{a(b)}.must_equal 'SELECT min(a(b)) AS min FROM test LIMIT 1'
-    @d.max{a(b)}.must_equal 'SELECT max(a(b)) AS max FROM test LIMIT 1'
+    5.times do
+      @d.avg{a(b)}.must_equal 'SELECT avg(a(b)) AS avg FROM test LIMIT 1'
+      @d.sum{a(b)}.must_equal 'SELECT sum(a(b)) AS sum FROM test LIMIT 1'
+      @d.min{a(b)}.must_equal 'SELECT min(a(b)) AS min FROM test LIMIT 1'
+      @d.max{a(b)}.must_equal 'SELECT max(a(b)) AS max FROM test LIMIT 1'
+    end
   end
 end
 
 describe "Dataset#range" do
   before do
     @db = Sequel.mock(:fetch=>{:v1 => 1, :v2 => 10})
-    @ds = @db[:test]
+    @ds = @db[:test].freeze
   end
   
   it "should generate a correct SQL statement" do
-    @ds.range(:stamp)
-    @db.sqls.must_equal ["SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test LIMIT 1"]
+    5.times do
+      @ds.range(:stamp)
+      @db.sqls.must_equal ["SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test LIMIT 1"]
+    end
 
     @ds.filter(Sequel.expr(:price) > 100).range(:stamp)
     @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
-    @ds.range(:tryme).must_equal(1..10)
+    5.times do
+      @ds.range(:tryme).must_equal(1..10)
+    end
   end
   
   it "should use a subselect for the same conditions as count" do
@@ -2524,33 +2459,42 @@ describe "Dataset#range" do
   end
   
   it "should accept virtual row blocks" do
-    @ds.range{a(b)}
-    @db.sqls.must_equal ["SELECT min(a(b)) AS v1, max(a(b)) AS v2 FROM test LIMIT 1"]
+    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"]
+    end
   end
 end
 
 describe "Dataset#interval" do
   before do
     @db = Sequel.mock(:fetch=>{:v => 1234})
-    @ds = @db[:test]
+    @ds = @db[:test].freeze
   end
   
   it "should generate the correct SQL statement" do
-    @ds.interval(:stamp)
-    @db.sqls.must_equal ["SELECT (max(stamp) - min(stamp)) AS interval FROM test LIMIT 1"]
+    5.times do
+      @ds.interval(:stamp)
+      @db.sqls.must_equal ["SELECT (max(stamp) - min(stamp)) AS interval FROM test LIMIT 1"]
+    end
 
     @ds.filter(Sequel.expr(:price) > 100).interval(:stamp)
     @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
-    @ds.order(:stamp).limit(5).interval(:stamp).must_equal 1234
-    @db.sqls.must_equal ['SELECT (max(stamp) - min(stamp)) AS interval FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1']
+    ds = @ds.order(:stamp).limit(5)
+    5.times do
+      ds.interval(:stamp).must_equal 1234
+      @db.sqls.must_equal ['SELECT (max(stamp) - min(stamp)) AS interval FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1']
+    end
   end
 
   it "should accept virtual row blocks" do
-    @ds.interval{a(b)}
-    @db.sqls.must_equal ["SELECT (max(a(b)) - min(a(b))) AS interval FROM test LIMIT 1"]
+    5.times do
+      @ds.interval{a(b)}
+      @db.sqls.must_equal ["SELECT (max(a(b)) - min(a(b))) AS interval FROM test LIMIT 1"]
+    end
   end
 end
 
@@ -2560,43 +2504,59 @@ describe "Dataset #first and #last" do
   end
   
   it "should return a single record if no argument is given" do
-    @d.order(:a).first.must_equal(:s=>'SELECT * FROM test ORDER BY a LIMIT 1')
-    @d.order(:a).last.must_equal(:s=>'SELECT * FROM test ORDER BY a DESC LIMIT 1')
+    ds = @d.order(:a).freeze
+    3.times do
+      ds.first.must_equal(:s=>'SELECT * FROM test ORDER BY a LIMIT 1')
+      ds.last.must_equal(:s=>'SELECT * FROM test ORDER BY a DESC LIMIT 1')
+    end
   end
 
   it "should return the first/last matching record if argument is not an Integer" do
-    @d.order(:a).first(:z => 26).must_equal(:s=>'SELECT * FROM test WHERE (z = 26) ORDER BY a LIMIT 1')
-    @d.order(:a).first('z = ?', 15).must_equal(:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a LIMIT 1')
-    @d.order(:a).last(:z => 26).must_equal(:s=>'SELECT * FROM test WHERE (z = 26) ORDER BY a DESC LIMIT 1')
-    @d.order(:a).last('z = ?', 15).must_equal(:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a DESC LIMIT 1')
+    ds = @d.order(:a).freeze
+    5.times do
+      ds.first(:z => 26).must_equal(:s=>'SELECT * FROM test WHERE (z = 26) ORDER BY a LIMIT 1')
+      ds.first('z = ?', 15).must_equal(:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a LIMIT 1')
+      ds.last(:z => 26).must_equal(:s=>'SELECT * FROM test WHERE (z = 26) ORDER BY a DESC LIMIT 1')
+      ds.last('z = ?', 15).must_equal(:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a DESC LIMIT 1')
+    end
   end
   
   it "should set the limit and return an array of records if the given number is > 1" do
-    i = rand(10) + 10
-    r = @d.order(:a).first(i).must_equal [{:s=>"SELECT * FROM test ORDER BY a LIMIT #{i}"}]
-    i = rand(10) + 10
-    r = @d.order(:a).last(i).must_equal [{:s=>"SELECT * FROM test ORDER BY a DESC LIMIT #{i}"}]
+    ds = @d.order(:a).freeze
+    5.times do
+      i = rand(10) + 10
+      ds.first(i).must_equal [{:s=>"SELECT * FROM test ORDER BY a LIMIT #{i}"}]
+      ds.last(i).must_equal [{:s=>"SELECT * FROM test ORDER BY a DESC LIMIT #{i}"}]
+    end
   end
   
   it "should return the first matching record if a block is given without an argument" do
-    @d.first{z > 26}.must_equal(:s=>'SELECT * FROM test WHERE (z > 26) LIMIT 1')
-    @d.order(:name).last{z > 26}.must_equal(:s=>'SELECT * FROM test WHERE (z > 26) ORDER BY name DESC LIMIT 1')
+    ds = @d.order(:name).freeze
+    5.times do
+      @d.first{z > 26}.must_equal(:s=>'SELECT * FROM test WHERE (z > 26) LIMIT 1')
+      ds.last{z > 26}.must_equal(:s=>'SELECT * FROM test WHERE (z > 26) ORDER BY name DESC LIMIT 1')
+    end
   end
   
   it "should combine block and standard argument filters if argument is not an Integer" do
-    @d.first(:y=>25){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((z > 26) AND (y = 25)) LIMIT 1')
-    @d.order(:name).last('y = ?', 16){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((z > 26) AND (y = 16)) ORDER BY name DESC LIMIT 1')
+    ds = @d.order(:name).freeze
+    5.times do
+      @d.first(:y=>25){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 25) AND (z > 26)) LIMIT 1')
+      ds.last('y = ?', 16){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 16) AND (z > 26)) ORDER BY name DESC LIMIT 1')
+    end
   end
   
   it "should filter and return an array of records if an Integer argument is provided and a block is given" do
-    i = rand(10) + 10
-    r = @d.order(:a).first(i){z > 26}.must_equal [{:s=>"SELECT * FROM test WHERE (z > 26) ORDER BY a LIMIT #{i}"}]
-    i = rand(10) + 10
-    r = @d.order(:a).last(i){z > 26}.must_equal [{:s=>"SELECT * FROM test WHERE (z > 26) ORDER BY a DESC LIMIT #{i}"}]
+    ds = @d.order(:a).freeze
+    5.times do
+      i = rand(10) + 10
+      ds.first(i){z > 26}.must_equal [{:s=>"SELECT * FROM test WHERE (z > 26) ORDER BY a LIMIT #{i}"}]
+      ds.last(i){z > 26}.must_equal [{:s=>"SELECT * FROM test WHERE (z > 26) ORDER BY a DESC LIMIT #{i}"}]
+    end
   end
 
   it "should return nil if no records match" do
-    Sequel.mock[:t].first.must_equal nil
+    Sequel.mock[:t].first.must_be_nil
   end
   
   it "#last should raise if no order is given" do
@@ -2639,7 +2599,7 @@ describe "Dataset #first!" do
   end
   
   it "should combine block and standard argument filters if argument is not an Integer" do
-    @d.first!(:y=>25){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((z > 26) AND (y = 25)) LIMIT 1')
+    @d.first!(:y=>25){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 25) AND (z > 26)) LIMIT 1')
   end
   
   it "should filter and return an array of records if an Integer argument is provided and a block is given" do
@@ -2701,7 +2661,7 @@ describe "Dataset compound operations" do
   end
 
   it "should raise an InvalidOperation if INTERSECT or EXCEPT is used and they are not supported" do
-    meta_def(@a, :supports_intersect_except?){false}
+    @a = @a.with_extend{def supports_intersect_except?; false end}
     proc{@a.intersect(@b)}.must_raise(Sequel::InvalidOperation)
     proc{@a.intersect(@b,:all=> true)}.must_raise(Sequel::InvalidOperation)
     proc{@a.except(@b)}.must_raise(Sequel::InvalidOperation)
@@ -2709,7 +2669,7 @@ describe "Dataset compound operations" do
   end
     
   it "should raise an InvalidOperation if INTERSECT ALL or EXCEPT ALL is used and they are not supported" do
-    meta_def(@a, :supports_intersect_except_all?){false}
+    @a = @a.with_extend{def supports_intersect_except_all?; false end}
     @a.intersect(@b)
     proc{@a.intersect(@b, :all=>true)}.must_raise(Sequel::InvalidOperation)
     @a.except(@b)
@@ -2751,8 +2711,10 @@ describe "Dataset compound operations" do
 
   it "should hoist WITH clauses in given dataset if dataset doesn't support WITH in subselect" do
     ds = Sequel.mock.dataset
-    meta_def(ds, :supports_cte?){true}
-    meta_def(ds, :supports_cte_in_subselect?){false}
+    ds = ds.with_extend do
+      def supports_cte?; true end
+      def supports_cte_in_subselect?; false end
+    end
     ds.from(:a).union(ds.from(:c).with(:c, ds.from(:d)), :from_self=>false).sql.must_equal 'WITH c AS (SELECT * FROM d) SELECT * FROM a UNION SELECT * FROM c'
     ds.from(:a).except(ds.from(:c).with(:c, ds.from(:d))).sql.must_equal 'WITH c AS (SELECT * FROM d) SELECT * FROM (SELECT * FROM a EXCEPT SELECT * FROM c) AS t1'
     ds.from(:a).with(:a, ds.from(:b)).intersect(ds.from(:c).with(:c, ds.from(:d)), :from_self=>false).sql.must_equal 'WITH a AS (SELECT * FROM b), c AS (SELECT * FROM d) SELECT * FROM a INTERSECT SELECT * FROM c'
@@ -2786,7 +2748,7 @@ describe "Dataset#single_record" do
   end
   
   it "should return nil if no record is present" do
-    @db[:test].single_record.must_equal nil
+    @db[:test].single_record.must_be_nil
     @db.sqls.must_equal ['SELECT * FROM test LIMIT 1']
   end
 end
@@ -2803,7 +2765,7 @@ describe "Dataset#single_record!" do
   end
   
   it "should return nil if no record is present" do
-    @db[:test].single_record!.must_equal nil
+    @db[:test].single_record!.must_be_nil
     @db.sqls.must_equal ['SELECT * FROM test']
   end
 end
@@ -2820,7 +2782,7 @@ describe "Dataset#single_value" do
   end
   
   it "should return nil if no records" do
-    @db[:test].single_value.must_equal nil
+    @db[:test].single_value.must_be_nil
     @db.sqls.must_equal ['SELECT * FROM test LIMIT 1']
   end
   
@@ -2844,7 +2806,7 @@ describe "Dataset#single_value!" do
   end
   
   it "should return nil if no records" do
-    @db[:test].single_value!.must_equal nil
+    @db[:test].single_value!.must_be_nil
     @db.sqls.must_equal ['SELECT * FROM test']
   end
 end
@@ -2855,8 +2817,11 @@ describe "Dataset#get" do
   end
   
   it "should select the specified column and fetch its value" do
-    @d.get(:name).must_equal "SELECT name FROM test LIMIT 1"
-    @d.get(:abc).must_equal "SELECT abc FROM test LIMIT 1"
+    @d.freeze
+    5.times do
+      @d.get(:name).must_equal "SELECT name FROM test LIMIT 1"
+      @d.get(:abc).must_equal "SELECT abc FROM test LIMIT 1"
+    end
   end
   
   it "should work with filters" do
@@ -2864,7 +2829,17 @@ describe "Dataset#get" do
   end
   
   it "should work with aliased fields" do
-    @d.get(Sequel.expr(:x__b).as(:name)).must_equal "SELECT x.b AS name FROM test LIMIT 1"
+    @d.freeze
+    5.times do
+      @d.get(Sequel.expr(:x__b).as(:name)).must_equal "SELECT x.b AS name FROM test LIMIT 1"
+    end
+  end
+  
+  it "should work with plain strings" do
+    @d.freeze
+    5.times do
+      @d.get('a').must_equal "SELECT 'a' AS v FROM test LIMIT 1"
+    end
   end
   
   it "should accept a block that yields a virtual row" do
@@ -2882,7 +2857,7 @@ describe "Dataset#get" do
   end
 
   it "should support an array of expressions to get an array of results" do
-    @d._fetch = {:name=>1, :abc=>2}
+    @d = @d.with_fetch(:name=>1, :abc=>2)
     @d.get([:name, :abc]).must_equal [1, 2]
     @d.db.sqls.must_equal ['SELECT name, abc FROM test LIMIT 1']
   end
@@ -2892,33 +2867,32 @@ describe "Dataset#get" do
   end
   
   it "should handle an array with aliases" do
-    @d._fetch = {:name=>1, :abc=>2}
+    @d = @d.with_fetch(:name=>1, :abc=>2)
     @d.get([:n___name, Sequel.as(:a, :abc)]).must_equal [1, 2]
     @d.db.sqls.must_equal ['SELECT n AS name, a AS abc FROM test LIMIT 1']
   end
   
   it "should raise an Error if an alias cannot be determined" do
-    @d._fetch = {:name=>1, :abc=>2}
-    proc{@d.get([Sequel.+(:a, 1), :a])}.must_raise(Sequel::Error)
+    proc{@d.with_fetch(:name=>1, :abc=>2).get([Sequel.+(:a, 1), :a])}.must_raise(Sequel::Error)
   end
   
   it "should support an array of expressions in a virtual row" do
-    @d._fetch = {:name=>1, :abc=>2}
+    @d = @d.with_fetch(:name=>1, :abc=>2)
     @d.get{[name, n__abc]}.must_equal [1, 2]
     @d.db.sqls.must_equal ['SELECT name, n.abc FROM test LIMIT 1']
   end
   
   it "should work with static SQL" do
     @d.with_sql('SELECT foo').get(:name).must_equal "SELECT foo"
-    @d._fetch = {:name=>1, :abc=>2}
+    @d = @d.with_fetch(:name=>1, :abc=>2)
     @d.with_sql('SELECT foo').get{[name, n__abc]}.must_equal [1, 2]
     @d.db.sqls.must_equal ['SELECT foo'] * 2
   end
 
   it "should handle cases where no rows are returned" do
-    @d._fetch = []
-    @d.get(:n).must_equal nil
-    @d.get([:n, :a]).must_equal nil
+    @d = @d.with_fetch([])
+    @d.get(:n).must_be_nil
+    @d.get([:n, :a]).must_be_nil
     @d.db.sqls.must_equal ['SELECT n FROM test LIMIT 1', 'SELECT n, a FROM test LIMIT 1']
   end
 end
@@ -2926,8 +2900,7 @@ end
 describe "Dataset#set_row_proc" do
   before do
     @db = Sequel.mock(:fetch=>[{:a=>1}, {:a=>2}])
-    @dataset = @db[:items]
-    @dataset.row_proc = proc{|h| h[:der] = h[:a] + 2; h}
+    @dataset = @db[:items].with_row_proc(proc{|h| h[:der] = h[:a] + 2; h})
   end
   
   it "should cause dataset to pass all rows through the filter" do
@@ -3013,7 +2986,7 @@ describe "Dataset#columns" do
   
   it "should ignore any filters, orders, or DISTINCT clauses" do
     @dataset.db.columns = [:a]
-    @dataset.filter!(:b=>100).order!(:b).distinct!
+    @dataset = @dataset.where(:b=>100).order(:b).distinct
     @dataset.columns.must_equal [:a]
     @dataset.db.sqls.must_equal ['SELECT * FROM items LIMIT 1']
   end
@@ -3036,7 +3009,7 @@ describe "Dataset#import" do
   end
   
   it "should return nil without a query if no values" do
-    @ds.import(['x', 'y'], []).must_equal nil
+    @ds.import(['x', 'y'], []).must_be_nil
     @db.sqls.must_equal []
   end
 
@@ -3066,7 +3039,7 @@ describe "Dataset#import" do
   end
 
   it "should slice based on the default_import_slice option" do
-    def @ds.default_import_slice; 2 end
+    @ds = @ds.with_extend{def default_import_slice; 2 end}
     @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]])
     @db.sqls.must_equal ['BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2)",
@@ -3107,7 +3080,7 @@ describe "Dataset#import" do
   end
 
   it "should use correct sql for :values strategy" do
-    def @ds.multi_insert_sql_strategy; :values end
+    @ds = @ds.with_extend{def multi_insert_sql_strategy; :values end}
     @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]])
     @db.sqls.must_equal ['BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2), (3, 4), (5, 6)",
@@ -3123,7 +3096,7 @@ describe "Dataset#import" do
   end
 
   it "should use correct sql for :union strategy" do
-    def @ds.multi_insert_sql_strategy; :union end
+    @ds = @ds.with_extend{def multi_insert_sql_strategy; :union end}
     @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]])
     @db.sqls.must_equal ['BEGIN',
       "INSERT INTO items (x, y) SELECT 1, 2 UNION ALL SELECT 3, 4 UNION ALL SELECT 5, 6",
@@ -3139,8 +3112,10 @@ describe "Dataset#import" do
   end
 
   it "should use correct sql for :union strategy when FROM is required" do
-    def @ds.empty_from_sql; ' FROM foo' end
-    def @ds.multi_insert_sql_strategy; :union end
+    @ds = @ds.with_extend do
+      def empty_from_sql; ' FROM foo' end
+      def multi_insert_sql_strategy; :union end
+    end
     @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]])
     @db.sqls.must_equal ['BEGIN',
       "INSERT INTO items (x, y) SELECT 1, 2 FROM foo UNION ALL SELECT 3, 4 FROM foo UNION ALL SELECT 5, 6 FROM foo",
@@ -3164,7 +3139,7 @@ describe "Dataset#multi_insert" do
   end
   
   it "should return nil without a query if no values" do
-    @ds.multi_insert([]).must_equal nil
+    @ds.multi_insert([]).must_be_nil
     @db.sqls.must_equal []
   end
 
@@ -3269,51 +3244,6 @@ describe "Dataset#multi_insert" do
   end
 end
 
-describe "Dataset" do
-  before do
-    @d = Sequel.mock.dataset.from(:x)
-  end
-
-  it "should support self-changing select!" do
-    @d.select!(:y)
-    @d.sql.must_equal "SELECT y FROM x"
-  end
-  
-  it "should support self-changing from!" do
-    @d.from!(:y)
-    @d.sql.must_equal "SELECT * FROM y"
-  end
-
-  it "should support self-changing order!" do
-    @d.order!(:y)
-    @d.sql.must_equal "SELECT * FROM x ORDER BY y"
-  end
-  
-  it "should support self-changing filter!" do
-    @d.filter!(:y => 1)
-    @d.sql.must_equal "SELECT * FROM x WHERE (y = 1)"
-  end
-
-  it "should support self-changing filter! with block" do
-    @d.filter!{y < 2}
-    @d.sql.must_equal "SELECT * FROM x WHERE (y < 2)"
-  end
-  
-  it "should raise for ! methods that don't return a dataset" do
-    proc {@d.opts!}.must_raise(NoMethodError)
-  end
-  
-  it "should raise for missing methods" do
-    proc {@d.xuyz}.must_raise(NoMethodError)
-    proc {@d.xyz!}.must_raise(NoMethodError)
-    proc {@d.xyz?}.must_raise(NoMethodError)
-  end
-  
-  it "should support chaining of bang methods" do
-      @d.order!(:y).filter!(:y => 1).sql.must_equal "SELECT * FROM x WHERE (y = 1) ORDER BY y"
-  end
-end
-
 describe "Dataset#update_sql" do
   before do
     @ds = Sequel.mock.dataset.from(:items)
@@ -3414,13 +3344,13 @@ describe "Dataset#inspect" do
   end
 
   it "should include the class name and the corresponding SQL statement" do
-    Sequel::Dataset.new(Sequel.mock).from(:blah).inspect.must_equal '#<Sequel::Dataset: "SELECT * FROM blah">'
-    InspectDataset.new(Sequel.mock).from(:blah).inspect.must_equal '#<InspectDataset: "SELECT * FROM blah">'
+    Sequel::Dataset.new(Sequel.mock).from(:blah).inspect.must_equal '#<Sequel::Dataset: "SELECT * FROM \\"BLAH\\"">'
+    InspectDataset.new(Sequel.mock).from(:blah).inspect.must_equal '#<InspectDataset: "SELECT * FROM \\"BLAH\\"">'
   end
 
   it "should skip anonymous classes" do
-    Class.new(Class.new(Sequel::Dataset)).new(Sequel.mock).from(:blah).inspect.must_equal '#<Sequel::Dataset: "SELECT * FROM blah">'
-    Class.new(InspectDataset).new(Sequel.mock).from(:blah).inspect.must_equal '#<InspectDataset: "SELECT * FROM blah">'
+    Class.new(Class.new(Sequel::Dataset)).new(Sequel.mock).from(:blah).inspect.must_equal '#<Sequel::Dataset: "SELECT * FROM \\"BLAH\\"">'
+    Class.new(InspectDataset).new(Sequel.mock).from(:blah).inspect.must_equal '#<InspectDataset: "SELECT * FROM \\"BLAH\\"">'
   end
 end
 
@@ -3497,7 +3427,7 @@ describe "Dataset#grep" do
   end
 
   it "should support regexps if the database supports it" do
-    def @ds.supports_regexp?; true end
+    @ds = @ds.with_extend{def supports_regexp?; true end}
     @ds.grep(:title, /ruby/).sql.must_equal "SELECT * FROM posts WHERE ((title ~ 'ruby'))"
     @ds.grep(:title, [/^ruby/, 'ruby']).sql.must_equal "SELECT * FROM posts WHERE ((title ~ '^ruby') OR (title LIKE 'ruby' ESCAPE '\\'))"
   end
@@ -3529,7 +3459,7 @@ describe "Dataset default #fetch_rows, #insert, #update, #delete, #truncate, #ex
   end
   
   it "#truncate should execute truncate SQL" do
-    @ds.truncate.must_equal nil
+    @ds.truncate.must_be_nil
     @db.sqls.must_equal ["TRUNCATE TABLE items"]
   end
   
@@ -3596,7 +3526,7 @@ describe "Dataset#with_sql_*" do
 
   it "#with_sql_first should return nil if no rows returned" do
     @db.fetch = []
-    @ds.with_sql_first('SELECT * FROM foo').must_equal nil
+    @ds.with_sql_first('SELECT * FROM foo').must_be_nil
     @db.sqls.must_equal ["SELECT * FROM foo -- read_only"]
   end
 
@@ -3607,7 +3537,7 @@ describe "Dataset#with_sql_*" do
 
   it "#with_sql_single_value should return nil if no rows returned" do
     @db.fetch = []
-    @ds.with_sql_single_value('SELECT * FROM foo').must_equal nil
+    @ds.with_sql_single_value('SELECT * FROM foo').must_be_nil
     @db.sqls.must_equal ["SELECT * FROM foo -- read_only"]
   end
 end
@@ -3615,12 +3545,11 @@ end
 describe "Dataset prepared statements and bound variables " do
   before do
     @db = Sequel.mock
-    @ds = @db[:items]
-    meta_def(@ds, :insert_select_sql){|*v| "#{insert_sql(*v)} RETURNING *" }
+    @ds = @db[:items].with_extend{def insert_select_sql(*v) "#{insert_sql(*v)} RETURNING *" end}
   end
   
   it "#call should take a type and bind hash and interpolate it" do
-    @ds.filter(:num=>:$n).call(:each, :n=>1)
+    @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([:to_hash, :a, :b], :n=>1)
@@ -3629,6 +3558,7 @@ describe "Dataset prepared statements and bound variables " do
     @ds.filter(:num=>:$n).call(:delete, :n=>1)
     @ds.filter(:num=>:$n).call(:update, {:n=>1, :n2=>2}, :num=>:$n2)
     @ds.call(:insert, {:n=>1}, :num=>:$n)
+    @ds.call(:insert_pk, {:n=>1}, :num=>:$n)
     @ds.call(:insert_select, {:n=>1}, :num=>:$n)
     @db.sqls.must_equal [
       'SELECT * FROM items WHERE (num = 1)',
@@ -3640,6 +3570,7 @@ describe "Dataset prepared statements and bound variables " do
       'DELETE FROM items WHERE (num = 1)',
       'UPDATE items SET num = 2 WHERE (num = 1)',
       'INSERT INTO items (num) VALUES (1)',
+      'INSERT INTO items (num) VALUES (1)',
       'INSERT INTO items (num) VALUES (1) RETURNING *']
   end
     
@@ -3681,10 +3612,12 @@ describe "Dataset prepared statements and bound variables " do
   end
     
   it "#call and #prepare should handle returning" do
-    meta_def(@ds, :supports_returning?){|_| true}
-    meta_def(@ds, :insert_sql){|*v| "#{super(*v)} RETURNING *" }
-    meta_def(@ds, :update_sql){|*v| "#{super(*v)} RETURNING *" }
-    meta_def(@ds, :delete_sql){"#{super()} RETURNING *" }
+    @ds = @ds.with_extend do
+      def supports_returning?(_) true end
+      def insert_sql(*v) "#{super(*v)} RETURNING *" end
+      def update_sql(*v) "#{super(*v)} RETURNING *" end
+      def delete_sql; "#{super()} RETURNING *" end
+    end
     @ds = @ds.returning
     @ds.call(:insert, {:n=>1}, :num=>:$n)
     @ds.filter(:num=>:$n).call(:update, {:n=>1, :n2=>2}, :num=>:$n2)
@@ -3705,8 +3638,7 @@ describe "Dataset prepared statements and bound variables " do
   end
 
   it "PreparedStatement#prepare should not raise an error if preparing prepared statements is allowed" do
-    ps = @ds.prepare(:select, :select_n)
-    def ps.allow_preparing_prepared_statements?; true end
+    ps = @ds.prepare(:select, :select_n).with_extend{def allow_preparing_prepared_statements?; true end}
     ps.prepare(:select, :select_n2).call
     @db.sqls.must_equal ["SELECT * FROM items"]
   end
@@ -3728,7 +3660,7 @@ describe "Dataset prepared statements and bound variables " do
     
   it "should handle columns on prepared statements correctly" do
     @db.columns = [:num]
-    meta_def(@ds, :select_where_sql){|sql| super(sql); sql << " OR #{columns.first} = 1" if opts[:where]}
+    @ds = @ds.with_extend{def select_where_sql(sql) super(sql); sql << " OR #{columns.first} = 1" if opts[:where] end}
     @ds.filter(:num=>:$n).prepare(:select, :sn).sql.must_equal 'SELECT * FROM items WHERE (num = $n) OR num = 1'
     @db.sqls.must_equal ['SELECT * FROM items LIMIT 1']
   end
@@ -3759,26 +3691,32 @@ describe "Dataset prepared statements and bound variables " do
   end
 
   it "should handle usage with Dataset.prepared_statements_module" do
-    @ds.extend(Sequel::Dataset.send(:prepared_statements_module, :prepare_bind, [Sequel::Dataset::ArgumentMapper, Sequel::Dataset::PreparedStatementMethods]){def foo; :bar; end})
+    @ds = @ds.with_extend(Sequel::Dataset.send(:prepared_statements_module, :prepare_bind, [Sequel::Dataset::ArgumentMapper, Sequel::Dataset::PreparedStatementMethods]){def foo; :bar; end})
     @ds.foo.must_equal :bar
-    @ds.prepared_statement_name = 'foo'
+    @ds = @ds.clone(:prepared_statement_name => 'foo')
     @ds.call(:a=>1)
     @db.sqls.must_equal ["foo"]
   end
+
+  it "should support log_sql option" do
+    @ds.prepare(:select, :foo).log_sql.must_be_nil
+    @ds.clone(:log_sql=>true).prepare(:select, :foo).log_sql.must_equal true
+  end
 end
 
 describe Sequel::Dataset::UnnumberedArgumentMapper do
   before do
     @db = Sequel.mock
-    @ds = @db[:items].filter(:num=>:$n)
-    def @ds.execute(sql, opts={}, &block)
-      super(sql, opts.merge({:arguments=>bind_arguments}), &block)
-    end
-    def @ds.execute_dui(sql, opts={}, &block)
-      super(sql, opts.merge({:arguments=>bind_arguments}), &block)
-    end
-    def @ds.execute_insert(sql, opts={}, &block)
-      super(sql, opts.merge({:arguments=>bind_arguments}), &block)
+    @ds = @db[:items].filter(:num=>:$n).with_extend do
+      def execute(sql, opts={}, &block)
+        super(sql, opts.merge({:arguments=>bind_arguments}), &block)
+      end
+      def execute_dui(sql, opts={}, &block)
+        super(sql, opts.merge({:arguments=>bind_arguments}), &block)
+      end
+      def execute_insert(sql, opts={}, &block)
+        super(sql, opts.merge({:arguments=>bind_arguments}), &block)
+      end
     end
     @ps = []
     @ps << @ds.prepare(:select, :s)
@@ -3787,9 +3725,8 @@ describe Sequel::Dataset::UnnumberedArgumentMapper do
     @ps << @ds.prepare(:delete, :d)
     @ps << @ds.prepare(:insert, :i, :num=>:$n)
     @ps << @ds.prepare(:update, :u, :num=>:$n)
-    @ps.each do |p|
-      p.extend(Sequel::Dataset::ArgumentMapper) # Work around for old rbx
-      p.extend(Sequel::Dataset::UnnumberedArgumentMapper)
+    @ps.map! do |p|
+      p.with_extend(Sequel::Dataset::UnnumberedArgumentMapper)
     end
   end
 
@@ -3809,9 +3746,9 @@ describe Sequel::Dataset::UnnumberedArgumentMapper do
 
   it "should handle unrecognized statement types as :all" do
     ps = @ds.prepare(:select_all, :s)
-    ps.extend(Sequel::Dataset::ArgumentMapper)  # Work around for old rbx
-    ps.extend(Sequel::Dataset::UnnumberedArgumentMapper)
-    ps.prepared_sql
+    ps = ps.with_extend(Sequel::Dataset::UnnumberedArgumentMapper)
+    sql = ps.prepared_sql
+    ps.prepared_sql.must_be_same_as(sql)
     ps.call(:n=>1)
     @db.sqls.must_equal ["SELECT * FROM items WHERE (num = ?) -- args: [1]"]
   end
@@ -3845,7 +3782,7 @@ end
 
 describe "Sequel::Dataset#qualify" do
   before do
-    @ds = Sequel::Database.new[:t]
+    @ds = Sequel.mock[:t]
   end
 
   it "should qualify to the table if one is given" do
@@ -3926,7 +3863,7 @@ describe "Sequel::Dataset#qualify" do
   end
 
   it "should handle SQL::Functions with windows" do
-    meta_def(@ds, :supports_window_functions?){true}
+    @ds = @ds.with_extend{def supports_window_functions?; true end}
     @ds.select{sum(:a).over(:partition=>:b, :order=>:c)}.qualify.sql.must_equal 'SELECT sum(t.a) OVER (PARTITION BY t.b ORDER BY t.c) FROM t'
   end
 
@@ -3958,7 +3895,7 @@ end
 
 describe "Sequel::Dataset#unbind" do
   before do
-    @ds = Sequel::Database.new[:t]
+    @ds = Sequel.mock[:t]
     @u = proc{|ds| ds, bv = ds.unbind; [ds.sql, bv]}
   end
 
@@ -4037,9 +3974,8 @@ end
 
 describe "Sequel::Dataset #with and #with_recursive" do
   before do
-    @db = Sequel::Database.new
-    @ds = @db[:t]
-    def @ds.supports_cte?(*) true end
+    @db = Sequel.mock
+    @ds = @db[:t].with_extend{def supports_cte?(*) true end}
   end
   
   it "#with should take a name and dataset and use a WITH clause" do
@@ -4072,24 +4008,27 @@ describe "Sequel::Dataset #with and #with_recursive" do
   end
 
   it "#with and #with_recursive should raise an error unless the dataset supports CTEs" do
-    meta_def(@ds, :supports_cte?){false}
+    @ds = @ds.with_extend{def supports_cte?; false end}
     proc{@ds.with(:t, @db[:x], :args=>[:b])}.must_raise(Sequel::Error)
     proc{@ds.with_recursive(:t, @db[:x], @db[:t], :args=>[:b, :c])}.must_raise(Sequel::Error)
   end
 
   it "#with should work on insert, update, and delete statements if they support it" do
-    sc = class << @ds; self; end
-    Sequel::Dataset.def_sql_method(sc, :delete, %w'with delete from where')
-    Sequel::Dataset.def_sql_method(sc, :insert, %w'with insert into columns values')
-    Sequel::Dataset.def_sql_method(sc, :update, %w'with update table set where')
+    @ds = @ds.with_extend do
+      Sequel::Dataset.def_sql_method(self, :delete, %w'with delete from where')
+      Sequel::Dataset.def_sql_method(self, :insert, %w'with insert into columns values')
+      Sequel::Dataset.def_sql_method(self, :update, %w'with update table set where')
+    end
     @ds.with(:t, @db[:x]).insert_sql(1).must_equal 'WITH t AS (SELECT * FROM x) INSERT INTO t VALUES (1)'
     @ds.with(:t, @db[:x]).update_sql(:foo=>1).must_equal 'WITH t AS (SELECT * FROM x) UPDATE t SET foo = 1'
     @ds.with(:t, @db[:x]).delete_sql.must_equal 'WITH t AS (SELECT * FROM x) DELETE FROM t'
   end
 
   it "should hoist WITH clauses in given dataset(s) if dataset doesn't support WITH in subselect" do
-    meta_def(@ds, :supports_cte?){true}
-    meta_def(@ds, :supports_cte_in_subselect?){false}
+    @ds = @ds.with_extend do
+      def supports_cte?; true end
+      def supports_cte_in_subselect?; false end
+    end
     @ds.with(:t, @ds.from(:s).with(:s, @ds.from(:r))).sql.must_equal 'WITH s AS (SELECT * FROM r), t AS (SELECT * FROM s) SELECT * FROM t'
     @ds.with_recursive(:t, @ds.from(:s).with(:s, @ds.from(:r)), @ds.from(:q).with(:q, @ds.from(:p))).sql.must_equal 'WITH s AS (SELECT * FROM r), q AS (SELECT * FROM p), t AS (SELECT * FROM s UNION ALL SELECT * FROM q) SELECT * FROM t'
   end
@@ -4143,9 +4082,10 @@ end
 describe "Sequel timezone support" do
   before do
     @db = Sequel::Database.new
-    @dataset = @db.dataset
-    meta_def(@dataset, :supports_timestamp_timezones?){true}
-    meta_def(@dataset, :supports_timestamp_usecs?){false}
+    @dataset = @db.dataset.with_extend do
+      def supports_timestamp_timezones?; true end
+      def supports_timestamp_usecs?; false end
+    end
     @utc_time = Time.utc(2010, 1, 2, 3, 4, 5)
     @local_time = Time.local(2010, 1, 2, 3, 4, 5)
     @offset = sprintf("%+03i%02i", *(@local_time.utc_offset/60).divmod(60))
@@ -4280,9 +4220,9 @@ describe "Sequel timezone support" do
   end
 
   it "should have Sequel.default_timezone= should set all other timezones" do
-    Sequel.database_timezone.must_equal nil
-    Sequel.application_timezone.must_equal nil
-    Sequel.typecast_timezone.must_equal nil
+    Sequel.database_timezone.must_be_nil
+    Sequel.application_timezone.must_be_nil
+    Sequel.typecast_timezone.must_be_nil
     Sequel.default_timezone = :utc
     Sequel.database_timezone.must_equal :utc
     Sequel.application_timezone.must_equal :utc
@@ -4562,8 +4502,7 @@ end
 
 describe "Modifying joined datasets" do
   before do
-    @ds = Sequel.mock.from(:b, :c).join(:d, [:id]).where(:id => 2)
-    meta_def(@ds, :supports_modifying_joins?){true}
+    @ds = Sequel.mock.from(:b, :c).join(:d, [:id]).where(:id => 2).with_extend{def supports_modifying_joins?; true end}
   end
 
   it "should allow deleting from joined datasets" do
@@ -4583,7 +4522,9 @@ describe "Dataset#lock_style and for_update" do
   end
   
   it "#for_update should use FOR UPDATE" do
-    @ds.for_update.sql.must_equal "SELECT * FROM t FOR UPDATE"
+    3.times do
+      @ds.for_update.sql.must_equal "SELECT * FROM t FOR UPDATE"
+    end
   end
   
   it "#lock_style should accept symbols" do
@@ -4605,10 +4546,14 @@ describe "Dataset#skip_locked" do
   end
   
   it "should skipped locked rows if supported" do
-    def @ds.supports_skip_locked?; true end
-    def @ds.select_lock_sql(sql) super; sql << " SKIP LOCKED" if @opts[:skip_locked] end
+    @ds = @ds.with_extend do
+      def supports_skip_locked?; true end
+      def select_lock_sql(sql) super; sql << " SKIP LOCKED" if @opts[:skip_locked] end
+    end
     @ds.sql.must_equal "SELECT * FROM t FOR UPDATE"
-    @ds.skip_locked.sql.must_equal "SELECT * FROM t FOR UPDATE SKIP LOCKED"
+    3.times do
+      @ds.skip_locked.sql.must_equal "SELECT * FROM t FOR UPDATE SKIP LOCKED"
+    end
   end
 end
   
@@ -4631,10 +4576,11 @@ describe "Dataset#returning" do
     @db.extend_datasets{def supports_returning?(type) true end}
     @ds = @db[:t].returning(:foo)
     @pr = proc do
-      sc = class << @ds; self; end
-      Sequel::Dataset.def_sql_method(sc, :delete, %w'delete from where returning')
-      Sequel::Dataset.def_sql_method(sc, :insert, %w'insert into columns values returning')
-      Sequel::Dataset.def_sql_method(sc, :update, %w'update table set where returning')
+      @ds = @ds.with_extend do
+        Sequel::Dataset.def_sql_method(self, :delete, %w'delete from where returning')
+        Sequel::Dataset.def_sql_method(self, :insert, %w'insert into columns values returning')
+        Sequel::Dataset.def_sql_method(self, :update, %w'update table set where returning')
+      end
     end
   end
   
@@ -4677,9 +4623,10 @@ end
 
 describe "Dataset emulating bitwise operator support" do
   before do
-    @ds = Sequel::Database.new.dataset.with_quote_identifiers(true)
-    def @ds.complex_expression_sql_append(sql, op, args)
-      complex_expression_arg_pairs_append(sql, args){|a, b| Sequel.function(:bitand, a, b)}
+    @ds = Sequel.mock.dataset.with_quote_identifiers(true).with_extend do
+      def complex_expression_sql_append(sql, op, args)
+        complex_expression_arg_pairs_append(sql, args){|a, b| Sequel.function(:bitand, a, b)}
+      end
     end
   end
 
@@ -4717,7 +4664,7 @@ describe "Dataset extensions" do
     end
   end
   before do
-    @ds = Sequel.mock.dataset
+    @ds = Sequel.mock(:identifier_mangling=>false).dataset
   end
 
   it "should be able to register an extension with a module Database#extension extend the module" do
@@ -4726,24 +4673,19 @@ describe "Dataset extensions" do
   end
 
   it "should be able to register an extension with a block and Database#extension call the block" do
-    @ds = @ds.with_quote_identifiers(false)
-    Sequel::Dataset.register_extension(:foo){|db| db.quote_identifiers = true}
-    @ds.extension(:foo).quote_identifiers?.must_equal true
+    Sequel::Dataset.register_extension(:foo){|ds| ds.extend(Module.new{def a; 1; end})}
+    @ds.extension(:foo).a.must_equal 1
   end
 
   it "should be able to register an extension with a callable and Database#extension call the callable" do
-    @ds = @ds.with_quote_identifiers(false)
-    Sequel::Dataset.register_extension(:foo, proc{|db| db.quote_identifiers = true})
-    @ds.extension(:foo).quote_identifiers?.must_equal true
+    Sequel::Dataset.register_extension(:foo, proc{|ds| ds.extend(Module.new{def a; 1; end})})
+    @ds.extension(:foo).a.must_equal 1
   end
 
   it "should be able to load multiple extensions in the same call" do
-    @ds = @ds.with_quote_identifiers(false).with_identifier_input_method(:downcase)
-    Sequel::Dataset.register_extension(:foo, proc{|ds| ds.quote_identifiers = true})
-    Sequel::Dataset.register_extension(:bar, proc{|ds| ds.identifier_input_method = nil})
-    ds = @ds.extension(:foo, :bar)
-    ds.quote_identifiers?.must_equal true
-    ds.identifier_input_method.must_equal nil
+    Sequel::Dataset.register_extension(:foo, proc{|ds| ds.send(:cache_set, :_columns, ds.columns + [:a])})
+    Sequel::Dataset.register_extension(:bar, proc{|ds| ds.send(:cache_set, :_columns, ds.columns + [:b])})
+    @ds.extension(:foo, :bar).columns.must_equal [:a, :b]
   end
 
   it "should have #extension not modify the receiver" do
@@ -4753,7 +4695,7 @@ describe "Dataset extensions" do
   end
 
   it "should have #extension not return a cloned dataset" do
-    @ds.extend(Module.new{def b; 2; end})
+    @ds = @ds.with_extend(Module.new{def b; 2; end})
     Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
     v = @ds.extension(:foo)
     v.must_equal(@ds)
@@ -4761,20 +4703,9 @@ describe "Dataset extensions" do
     v.b.must_equal 2
   end
 
-  it "should have #extension! modify the receiver" do
-    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
-    @ds.extension!(:foo)
-    @ds.a.must_equal 1
-  end
-
-  it "should have #extension! return the receiver" do
-    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
-    @ds.extension!(:foo).must_be_same_as(@ds)
-  end
-
   it "should register a Database extension for modifying all datasets when registering with a module" do
     Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
-    Sequel.mock.extension(:foo).dataset.a.must_equal 1
+    Sequel.mock(:identifier_mangling=>false).extension(:foo).dataset.a.must_equal 1
   end
 
   it "should raise an Error if registering with both a module and a block" do
@@ -4852,9 +4783,8 @@ end
 
 describe "Dataset#paged_each" do
   before do
-    @ds = Sequel.mock[:test].order(:x)
     @db = (0...10).map{|i| {:x=>i}}
-    @ds._fetch = @db
+    @ds = Sequel.mock[:test].order(:x).with_fetch(@db)
     @rows = []
     @proc = lambda{|row| @rows << row}
   end
@@ -4870,7 +4800,7 @@ describe "Dataset#paged_each" do
   end
 
   it "should respect the row_proc" do
-    @ds.row_proc = lambda{|row| {:x=>row[:x]*2}}
+    @ds = @ds.with_row_proc(lambda{|row| {:x=>row[:x]*2}})
     @ds.paged_each(&@proc)
     @rows.must_equal @db.map{|row| {:x=>row[:x]*2}}
   end
@@ -4888,7 +4818,7 @@ describe "Dataset#paged_each" do
   end
 
   it "should accept a :rows_per_fetch option to change the number of rows per fetch" do
-    @ds._fetch = @db.each_slice(3).to_a
+    @ds = @ds.with_fetch(@db.each_slice(3).to_a)
     @ds.paged_each(:rows_per_fetch=>3, &@proc)
     @rows.must_equal @db
     @ds.db.sqls[1...-1].must_equal ['SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 0',
@@ -4898,7 +4828,7 @@ describe "Dataset#paged_each" do
   end
 
   it "should handle cases where the last query returns nothing" do
-    @ds._fetch = @db.each_slice(5).to_a
+    @ds = @ds.with_fetch(@db.each_slice(5).to_a)
     @ds.paged_each(:rows_per_fetch=>5, &@proc)
     @rows.must_equal @db
     @ds.db.sqls[1...-1].must_equal ['SELECT * FROM test ORDER BY x LIMIT 5 OFFSET 0',
@@ -4908,7 +4838,7 @@ describe "Dataset#paged_each" do
 
   it "should respect an existing server option to use" do
     @ds = Sequel.mock(:servers=>{:foo=>{}})[:test].order(:x)
-    @ds._fetch = @db
+    @ds = @ds.with_fetch(@db)
     @ds.server(:foo).paged_each(&@proc)
     @rows.must_equal @db
     @ds.db.sqls.must_equal ["BEGIN -- foo", "SELECT * FROM test ORDER BY x LIMIT 1000 OFFSET 0 -- foo", "COMMIT -- foo"]
@@ -4919,28 +4849,28 @@ describe "Dataset#paged_each" do
   end
 
   it "should handle an existing limit and/or offset" do
-    @ds._fetch = @db.each_slice(3).to_a
+    @ds = @ds.with_fetch(@db.each_slice(3).to_a)
     @ds.limit(5).paged_each(:rows_per_fetch=>3, &@proc)
     @ds.db.sqls[1...-1].must_equal ["SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 0", "SELECT * FROM test ORDER BY x LIMIT 2 OFFSET 3"]
 
-    @ds._fetch = @db.each_slice(3).to_a
+    @ds = @ds.with_fetch(@db.each_slice(3).to_a)
     @ds.limit(5, 2).paged_each(:rows_per_fetch=>3, &@proc)
     @ds.db.sqls[1...-1].must_equal ["SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 2", "SELECT * FROM test ORDER BY x LIMIT 2 OFFSET 5"]
 
-    @ds._fetch = @db.each_slice(3).to_a
+    @ds = @ds.with_fetch(@db.each_slice(3).to_a)
     @ds.limit(nil, 2).paged_each(:rows_per_fetch=>3, &@proc)
     @ds.db.sqls[1...-1].must_equal ["SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 2", "SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 5", "SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 8", "SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 11"]
   end
 
   it "should support :strategy=>:filter" do
-    @ds._fetch = @db.each_slice(5).to_a
+    @ds = @ds.with_fetch(@db.each_slice(5).to_a)
     @ds.paged_each(:rows_per_fetch=>5, :strategy=>:filter, &@proc)
     @ds.db.sqls[1...-1].must_equal ["SELECT * FROM test ORDER BY x LIMIT 5", "SELECT * FROM test WHERE (x > 4) ORDER BY x LIMIT 5", "SELECT * FROM test WHERE (x > 9) ORDER BY x LIMIT 5"]
     @rows.must_equal @db
 
     @rows = []
     db = @db.map{|h| h[:y] = h[:x] % 5; h[:z] = h[:x] % 9; h}.sort_by{|h| [h[:z], -h[:y], h[:x]]}
-    @ds._fetch = db.each_slice(5).to_a
+    @ds = @ds.with_fetch(db.each_slice(5).to_a)
     @ds.order(Sequel.identifier(:z), Sequel.desc(Sequel.qualify(:test, :y)), Sequel.asc(:x)).paged_each(:rows_per_fetch=>5, :strategy=>:filter, &@proc)
     @ds.db.sqls[1...-1].must_equal ["SELECT * FROM test ORDER BY z, test.y DESC, x ASC LIMIT 5",
       "SELECT * FROM test WHERE ((z > 3) OR ((z = 3) AND (test.y < 3)) OR ((z = 3) AND (test.y = 3) AND (x > 3))) ORDER BY z, test.y DESC, x ASC LIMIT 5",
@@ -4950,7 +4880,7 @@ describe "Dataset#paged_each" do
 
   it "should support :strategy=>:filter with :filter_values option" do
     db = @db.map{|h| h[:y] = h[:x] % 5; h[:z] = h[:x] % 9; h}.sort_by{|h| [h[:z], -h[:y], h[:x]]}
-    @ds._fetch = db.each_slice(5).to_a
+    @ds = @ds.with_fetch(db.each_slice(5).to_a)
     @ds.order(Sequel.identifier(:z), Sequel.desc(Sequel.qualify(:test, :y) * 2), Sequel.asc(:x)).paged_each(:rows_per_fetch=>5, :strategy=>:filter, :filter_values=>proc{|row, expr| [row[expr[0].value], row[expr[1].args.first.column] * expr[1].args.last, row[expr[2]]]}, &@proc)
     @ds.db.sqls[1...-1].must_equal ["SELECT * FROM test ORDER BY z, (test.y * 2) DESC, x ASC LIMIT 5",
       "SELECT * FROM test WHERE ((z > 3) OR ((z = 3) AND ((test.y * 2) < 6)) OR ((z = 3) AND ((test.y * 2) = 6) AND (x > 3))) ORDER BY z, (test.y * 2) DESC, x ASC LIMIT 5",
@@ -5024,102 +4954,21 @@ describe "Frozen Datasets" do
     @ds.must_equal @ds.db[:test]
   end
 
-  it "should have dups not be frozen" do
-    @ds.dup.wont_be :frozen?
-  end
-
-  it "should raise an error when calling mutation methods" do
-    proc{@ds.select!(:a)}.must_raise RuntimeError
-    proc{@ds.identifier_input_method = :a}.must_raise RuntimeError
-    proc{@ds.identifier_output_method = :a}.must_raise RuntimeError
-    proc{@ds.quote_identifiers = false}.must_raise RuntimeError
-    proc{@ds.row_proc = proc{}}.must_raise RuntimeError
-    proc{@ds.extension! :query}.must_raise RuntimeError
-    proc{@ds.naked!}.must_raise RuntimeError
-    proc{@ds.from_self!}.must_raise RuntimeError
-  end
-
   it "should not raise an error when calling query methods" do
     @ds.select(:a).sql.must_equal 'SELECT a FROM test'
   end
 end
 
-describe "Dataset mutation methods" do
-  def m(&block)
-    ds = Sequel.mock[:t]
-    def ds.supports_cte?(*) true end
-    ds.instance_exec(&block)
-    ds.sql
-  end
-
-  it "should modify the dataset in place" do
-    dsc = Sequel.mock[:u]
-    dsc.instance_variable_set(:@columns, [:v])
-
-    m{and!(:a=>1).or!(:b=>2)}.must_equal "SELECT * FROM t WHERE ((a = 1) OR (b = 2))"
-    m{select!(:f).graph!(dsc, :b=>:c).set_graph_aliases!(:e=>[:m, :n]).add_graph_aliases!(:d=>[:g, :c])}.must_equal "SELECT m.n AS e, g.c AS d FROM t LEFT OUTER JOIN u ON (u.b = t.c)"
-    m{cross_join!(:a)}.must_equal "SELECT * FROM t CROSS JOIN a"
-    m{distinct!}.must_equal "SELECT DISTINCT * FROM t"
-    m{except!(dsc)}.must_equal "SELECT * FROM (SELECT * FROM t EXCEPT SELECT * FROM u) AS t1"
-    m{exclude!(:a=>1)}.must_equal "SELECT * FROM t WHERE (a != 1)"
-    m{exclude_having!(:a=>1)}.must_equal "SELECT * FROM t HAVING (a != 1)"
-    m{exclude_where!(:a=>1)}.must_equal "SELECT * FROM t WHERE (a != 1)"
-    m{filter!(:a=>1)}.must_equal "SELECT * FROM t WHERE (a = 1)"
-    m{for_update!}.must_equal "SELECT * FROM t FOR UPDATE"
-    m{from!(:p)}.must_equal "SELECT * FROM p"
-    m{full_join!(:a, [:b])}.must_equal "SELECT * FROM t FULL JOIN a USING (b)"
-    m{full_outer_join!(:a, [:b])}.must_equal "SELECT * FROM t FULL OUTER JOIN a USING (b)"
-    m{grep!(:a, 'b')}.must_equal "SELECT * FROM t WHERE ((a LIKE 'b' ESCAPE '\\'))"
-    m{group!(:a)}.must_equal "SELECT * FROM t GROUP BY a"
-    m{group_and_count!(:a)}.must_equal "SELECT a, count(*) AS count FROM t GROUP BY a"
-    m{group_by!(:a)}.must_equal "SELECT * FROM t GROUP BY a"
-    m{having!(:a)}.must_equal "SELECT * FROM t HAVING a"
-    m{inner_join!(:a, [:b])}.must_equal "SELECT * FROM t INNER JOIN a USING (b)"
-    m{intersect!(dsc)}.must_equal "SELECT * FROM (SELECT * FROM t INTERSECT SELECT * FROM u) AS t1"
-    m{where!(:a).invert!}.must_equal "SELECT * FROM t WHERE NOT a"
-    m{join!(:a, [:b])}.must_equal "SELECT * FROM t INNER JOIN a USING (b)"
-    m{join_table!(:inner, :a, [:b])}.must_equal "SELECT * FROM t INNER JOIN a USING (b)"
-    m{left_join!(:a, [:b])}.must_equal "SELECT * FROM t LEFT JOIN a USING (b)"
-    m{left_outer_join!(:a, [:b])}.must_equal "SELECT * FROM t LEFT OUTER JOIN a USING (b)"
-    m{limit!(1)}.must_equal "SELECT * FROM t LIMIT 1"
-    m{lock_style!(:update)}.must_equal "SELECT * FROM t FOR UPDATE"
-    m{natural_full_join!(:a)}.must_equal "SELECT * FROM t NATURAL FULL JOIN a"
-    m{natural_join!(:a)}.must_equal "SELECT * FROM t NATURAL JOIN a"
-    m{natural_left_join!(:a)}.must_equal "SELECT * FROM t NATURAL LEFT JOIN a"
-    m{natural_right_join!(:a)}.must_equal "SELECT * FROM t NATURAL RIGHT JOIN a"
-    m{offset!(1)}.must_equal "SELECT * FROM t OFFSET 1"
-    m{order!(:a).reverse_order!}.must_equal "SELECT * FROM t ORDER BY a DESC"
-    m{order_by!(:a).order_more!(:b).order_append!(:c).order_prepend!(:d).reverse!}.must_equal "SELECT * FROM t ORDER BY d DESC, a DESC, b DESC, c DESC"
-    m{qualify!}.must_equal "SELECT t.* FROM t"
-    m{right_join!(:a, [:b])}.must_equal "SELECT * FROM t RIGHT JOIN a USING (b)"
-    m{right_outer_join!(:a, [:b])}.must_equal "SELECT * FROM t RIGHT OUTER JOIN a USING (b)"
-    m{select!(:a)}.must_equal "SELECT a FROM t"
-    m{select_all!(:t).select_more!(:b).select_append!(:c)}.must_equal "SELECT t.*, b, c FROM t"
-    m{select_group!(:a)}.must_equal "SELECT a FROM t GROUP BY a"
-    m{where!(:a).unfiltered!}.must_equal "SELECT * FROM t"
-    m{group!(:a).ungrouped!}.must_equal "SELECT * FROM t"
-    m{limit!(1).unlimited!}.must_equal "SELECT * FROM t"
-    m{order!(:a).unordered!}.must_equal "SELECT * FROM t"
-    m{union!(dsc)}.must_equal "SELECT * FROM (SELECT * FROM t UNION SELECT * FROM u) AS t1"
-    m{with!(:a, dsc)}.must_equal "WITH a AS (SELECT * FROM u) SELECT * FROM t"
-    m{with_recursive!(:a, dsc, dsc)}.must_equal "WITH a AS (SELECT * FROM u UNION ALL SELECT * FROM u) SELECT * FROM t"
-    m{with_sql!('SELECT foo')}.must_equal "SELECT foo"
-
-    dsc.server!(:a)
-    dsc.opts[:server].must_equal :a
-    dsc.graph!(dsc, {:b=>:c}, :table_alias=>:foo).ungraphed!.opts[:graph].must_equal nil
-  end
-end
-
 describe "Dataset emulated complex expression operators" do
   before do
-    @ds = Sequel.mock[:test]
-    def @ds.complex_expression_sql_append(sql, op, args)
-      case op
-      when :&, :|, :^, :%, :<<, :>>, :'B~'
-        complex_expression_emulate_append(sql, op, args)
-      else
-        super
+    @ds = Sequel.mock[:test].with_extend do
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :&, :|, :^, :%, :<<, :>>, :'B~'
+          complex_expression_emulate_append(sql, op, args)
+        else
+          super
+        end
       end
     end
     @n = Sequel.expr(:x).sql_number
@@ -5212,12 +5061,20 @@ describe "#unqualified_column_for" do
   end
 
   it "should return nil for other objects" do
-    @ds.unqualified_column_for(Object.new).must_equal nil
-    @ds.unqualified_column_for('a').must_equal nil
+    @ds.unqualified_column_for(Object.new).must_be_nil
+    @ds.unqualified_column_for('a').must_be_nil
   end
 
   it "should return nil for other objects inside SQL::AliasedExpressions" do
-    @ds.unqualified_column_for(Sequel.as(Object.new, 'a')).must_equal nil
-    @ds.unqualified_column_for(Sequel.as('a', 'b')).must_equal nil
+    @ds.unqualified_column_for(Sequel.as(Object.new, 'a')).must_be_nil
+    @ds.unqualified_column_for(Sequel.as('a', 'b')).must_be_nil
+  end
+end
+
+describe "Dataset#output_identifier" do
+  it "should handle empty identifiers and uppercase identifiers" do
+    meth = Sequel::Database.new(:identifier_mangling=>false).dataset.method(:output_identifier)
+    meth.call('').must_equal :untitled
+    meth.call('A').must_equal :a
   end
 end