sequel 3.21.0 → 3.32.0

data/spec/core/dataset_spec.rb

@@ -60,12 +60,6 @@ describe "Dataset" do
     db = Sequel::Database.new(:identifier_output_method=>:downcase)
     db[:a].identifier_output_method.should == :downcase
   end
-end
-
-describe "Dataset" do
-  before do
-    @dataset = Sequel::Dataset.new("db")
-  end
   
   specify "should have quote_identifiers= method which changes literalization of identifiers" do
     @dataset.quote_identifiers = true
@@ -111,27 +105,25 @@ describe "Dataset#clone" do
   
   specify "should create an exact copy of the dataset" do
     @dataset.row_proc = Proc.new{|r| r}
-    @clone = @dataset.clone
+    clone = @dataset.clone
 
-    @clone.object_id.should_not === @dataset.object_id
-    @clone.class.should == @dataset.class
-    @clone.opts.should == @dataset.opts
-    @clone.row_proc.should == @dataset.row_proc
+    clone.object_id.should_not === @dataset.object_id
+    clone.class.should == @dataset.class
+    clone.db.should == @dataset.db
+    clone.opts.should == @dataset.opts
+    clone.row_proc.should == @dataset.row_proc
   end
   
   specify "should deep-copy the dataset opts" do
-    @clone = @dataset.clone
+    clone = @dataset.clone
 
-    @clone.opts.should_not equal(@dataset.opts)
+    clone.opts.should_not equal(@dataset.opts)
     @dataset.filter!(:a => 'b')
-    @clone.opts[:filter].should be_nil
-  end
-  
-  specify "should return a clone self" do
-    clone = @dataset.clone({})
-    clone.class.should == @dataset.class
-    clone.db.should == @dataset.db
-    clone.opts.should == @dataset.opts
+    clone.opts[:filter].should be_nil
+
+    clone = @dataset.clone(:from => [:other])
+    @dataset.opts[:from].should == [:items]
+    clone.opts[:from].should == [:other]
   end
   
   specify "should merge the specified options" do
@@ -144,12 +136,6 @@ describe "Dataset#clone" do
     clone.opts.should == {:from => [:other]}
   end
   
-  specify "should create a clone with a deep copy of options" do
-    clone = @dataset.clone(:from => [:other])
-    @dataset.opts[:from].should == [:items]
-    clone.opts[:from].should == [:other]
-  end
-  
   specify "should return an object with the same modules included" do
     m = Module.new do
       def __xyz__; "xyz"; end
@@ -161,7 +147,7 @@ end
 
 describe "Dataset#==" do
   before do
-    @db = MockDatabase.new
+    @db = Sequel.mock
     @h = {}
   end
   
@@ -170,7 +156,7 @@ describe "Dataset#==" do
   end
 
   specify "should be different for datasets with different dbs" do
-    @db[:t].should_not == MockDatabase.new[:t]
+    @db[:t].should_not == Sequel.mock[:t]
   end
   
   specify "should be different for datasets with different opts" do
@@ -186,7 +172,7 @@ end
 
 describe "Dataset#hash" do
   before do
-    @db = MockDatabase.new
+    @db = Sequel.mock
     @h = {}
   end
   
@@ -197,7 +183,7 @@ describe "Dataset#hash" do
   end
 
   specify "should be different for datasets with different dbs" do
-    @db[:t].hash.should_not == MockDatabase.new[:t].hash
+    @db[:t].hash.should_not == Sequel.mock[:t].hash
   end
   
   specify "should be different for datasets with different opts" do
@@ -232,6 +218,12 @@ describe "A simple dataset" do
     @dataset.insert_sql.should == 'INSERT INTO test DEFAULT VALUES'
   end
   
+  specify "should use a single column with a default value when the dataset doesn't support using insert statement with default values" do
+    @dataset.meta_def(:insert_supports_empty_values?){false}
+    @dataset.meta_def(:columns){[:a, :b]}
+    @dataset.insert_sql.should == 'INSERT INTO test (b) VALUES (DEFAULT)'
+  end
+  
   specify "should format an insert statement with hash" do
     @dataset.insert_sql(:name => 'wxyz', :price => 342).
       should match(/INSERT INTO test \(name, price\) VALUES \('wxyz', 342\)|INSERT INTO test \(price, name\) VALUES \(342, 'wxyz'\)/)
@@ -245,8 +237,6 @@ describe "A simple dataset" do
   end
   
   specify "should format an insert statement with an object that respond_to? :values" do
-    dbb = Sequel::Database.new
-    
     v = Object.new
     def v.values; {:a => 1}; end
     
@@ -261,29 +251,24 @@ describe "A simple dataset" do
   end
   
   specify "should format an insert statement with sub-query" do
-    @sub = Sequel::Dataset.new(nil).from(:something).filter(:x => 2)
-    @dataset.insert_sql(@sub).should == \
-      "INSERT INTO test SELECT * FROM something WHERE (x = 2)"
+    @dataset.insert_sql(@dataset.from(:something).filter(:x => 2)).should == "INSERT INTO test SELECT * FROM something WHERE (x = 2)"
   end
   
   specify "should format an insert statement with array" do
-    @dataset.insert_sql('a', 2, 6.5).should ==
-      "INSERT INTO test VALUES ('a', 2, 6.5)"
+    @dataset.insert_sql('a', 2, 6.5).should == "INSERT INTO test VALUES ('a', 2, 6.5)"
   end
   
   specify "should format an update statement" do
-    @dataset.update_sql(:name => 'abc').should ==
-      "UPDATE test SET name = 'abc'"
+    @dataset.update_sql(:name => 'abc').should == "UPDATE test SET name = 'abc'"
   end
 
   specify "should be able to return rows for arbitrary SQL" do
-    @dataset.clone(:sql => 'xxx yyy zzz').select_sql.should ==
-      "xxx yyy zzz"
+    @dataset.clone(:sql => 'xxx yyy zzz').select_sql.should == "xxx yyy zzz"
   end
 
   specify "should use the :sql option for all sql methods" do
     sql = "X"
-    ds = Sequel::Dataset.new(nil, :sql=>sql)
+    ds = @dataset.clone(:sql=>sql)
     ds.sql.should == sql
     ds.select_sql.should == sql
     ds.insert_sql.should == sql
@@ -357,12 +342,12 @@ describe "Dataset#exists" do
     @ds1.filter(@ds2.exists).sql.should ==
       'SELECT * FROM test WHERE (EXISTS (SELECT * FROM test WHERE (price < 100)))'
     @ds1.filter(@ds2.exists & @ds3.exists).sql.should ==
-      'SELECT * FROM test WHERE (EXISTS (SELECT * FROM test WHERE (price < 100)) AND EXISTS (SELECT * FROM test WHERE (price > 50)))'
+      'SELECT * FROM test WHERE ((EXISTS (SELECT * FROM test WHERE (price < 100))) AND (EXISTS (SELECT * FROM test WHERE (price > 50))))'
   end
 
   specify "should work in select" do
     @ds1.select(@ds2.exists.as(:a), @ds3.exists.as(:b)).sql.should ==
-      'SELECT EXISTS (SELECT * FROM test WHERE (price < 100)) AS a, EXISTS (SELECT * FROM test WHERE (price > 50)) AS b FROM test'
+      'SELECT (EXISTS (SELECT * FROM test WHERE (price < 100))) AS a, (EXISTS (SELECT * FROM test WHERE (price > 50))) AS b FROM test'
   end
 end
 
@@ -418,7 +403,7 @@ describe "Dataset#where" do
     b.should == a
   end
 
-  specify "should not replace named placeholders that don't existin in the hash" do
+  specify "should not replace named placeholders that don't exist in the hash" do
     @dataset.where('price < :price AND id in :ids', :price=>100).select_sql.should ==
       "SELECT * FROM test WHERE (price < 100 AND id in :ids)"
   end
@@ -510,62 +495,89 @@ describe "Dataset#where" do
       "SELECT * FROM test WHERE (gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia')))"
   end
   
+  specify "should handle all types of IN/NOT IN queries with empty arrays" do
+    @dataset.filter(:id => []).sql.should == "SELECT * FROM test WHERE (id != id)"
+    @dataset.filter([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE ((id1 != id1) AND (id2 != id2))"
+    @dataset.exclude(:id => []).sql.should == "SELECT * FROM test WHERE (id = id)"
+    @dataset.exclude([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE ((id1 = id1) AND (id2 = id2))"
+  end
+
+  specify "should handle all types of IN/NOT IN queries with empty arrays" do
+    begin
+      Sequel.empty_array_handle_nulls = false
+      @dataset.filter(:id => []).sql.should == "SELECT * FROM test WHERE (1 = 0)"
+      @dataset.filter([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE (1 = 0)"
+      @dataset.exclude(:id => []).sql.should == "SELECT * FROM test WHERE (1 = 1)"
+      @dataset.exclude([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE (1 = 1)"
+    ensure
+      Sequel.empty_array_handle_nulls = true
+    end
+  end
+
   specify "should handle all types of IN/NOT IN queries" do
     @dataset.filter(:id => @d1.select(:id)).sql.should == "SELECT * FROM test WHERE (id IN (SELECT id FROM test WHERE (region = 'Asia')))"
-    @dataset.filter(:id => []).sql.should == "SELECT * FROM test WHERE (id != id)"
     @dataset.filter(:id => [1, 2]).sql.should == "SELECT * FROM test WHERE (id IN (1, 2))"
     @dataset.filter([:id1, :id2] => @d1.select(:id1, :id2)).sql.should == "SELECT * FROM test WHERE ((id1, id2) IN (SELECT id1, id2 FROM test WHERE (region = 'Asia')))"
-    @dataset.filter([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE ((id1 != id1) AND (id2 != id2))"
     @dataset.filter([:id1, :id2] => [[1, 2], [3,4]].sql_array).sql.should == "SELECT * FROM test WHERE ((id1, id2) IN ((1, 2), (3, 4)))"
     @dataset.filter([:id1, :id2] => [[1, 2], [3,4]]).sql.should == "SELECT * FROM test WHERE ((id1, id2) IN ((1, 2), (3, 4)))"
 
     @dataset.exclude(:id => @d1.select(:id)).sql.should == "SELECT * FROM test WHERE (id NOT IN (SELECT id FROM test WHERE (region = 'Asia')))"
-    @dataset.exclude(:id => []).sql.should == "SELECT * FROM test WHERE (1 = 1)"
     @dataset.exclude(:id => [1, 2]).sql.should == "SELECT * FROM test WHERE (id NOT IN (1, 2))"
     @dataset.exclude([:id1, :id2] => @d1.select(:id1, :id2)).sql.should == "SELECT * FROM test WHERE ((id1, id2) NOT IN (SELECT id1, id2 FROM test WHERE (region = 'Asia')))"
-    @dataset.exclude([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE (1 = 1)"
     @dataset.exclude([:id1, :id2] => [[1, 2], [3,4]].sql_array).sql.should == "SELECT * FROM test WHERE ((id1, id2) NOT IN ((1, 2), (3, 4)))"
     @dataset.exclude([:id1, :id2] => [[1, 2], [3,4]]).sql.should == "SELECT * FROM test WHERE ((id1, id2) NOT IN ((1, 2), (3, 4)))"
   end
 
   specify "should handle IN/NOT IN queries with multiple columns and an array where the database doesn't support it" do
     @dataset.meta_def(:supports_multiple_column_in?){false}
-    @dataset.filter([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE ((id1 != id1) AND (id2 != id2))"
     @dataset.filter([:id1, :id2] => [[1, 2], [3,4]].sql_array).sql.should == "SELECT * FROM test WHERE (((id1 = 1) AND (id2 = 2)) OR ((id1 = 3) AND (id2 = 4)))"
-    @dataset.exclude([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE (1 = 1)"
     @dataset.exclude([:id1, :id2] => [[1, 2], [3,4]].sql_array).sql.should == "SELECT * FROM test WHERE (((id1 != 1) OR (id2 != 2)) AND ((id1 != 3) OR (id2 != 4)))"
   end
 
   specify "should handle IN/NOT IN queries with multiple columns and a dataset where the database doesn't support it" do
     @dataset.meta_def(:supports_multiple_column_in?){false}
-    d1 = @d1.select(:id1, :id2)
-    def d1.fetch_rows(sql)
-      @sql_used = sql
-      @columns = [:id1, :id2]
-      yield(:id1=>1, :id2=>2)
-      yield(:id1=>3, :id2=>4)
-    end
-    d1.instance_variable_get(:@sql_used).should == nil
+    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.should == "SELECT * FROM test WHERE (((id1 = 1) AND (id2 = 2)) OR ((id1 = 3) AND (id2 = 4)))"
-    d1.instance_variable_get(:@sql_used).should == "SELECT id1, id2 FROM test WHERE (region = 'Asia')"
-    d1.instance_variable_set(:@sql_used, nil)
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
     @dataset.exclude([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (((id1 != 1) OR (id2 != 2)) AND ((id1 != 3) OR (id2 != 4)))"
-    d1.instance_variable_get(:@sql_used).should == "SELECT id1, id2 FROM test WHERE (region = 'Asia')"
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
   end
   
   specify "should handle IN/NOT IN queries with multiple columns and an empty dataset where the database doesn't support it" do
     @dataset.meta_def(:supports_multiple_column_in?){false}
-    d1 = @d1.select(:id1, :id2)
-    def d1.fetch_rows(sql)
-      @sql_used = sql
-      @columns = [:id1, :id2]
-    end
-    d1.instance_variable_get(:@sql_used).should == nil
+    db = Sequel.mock
+    d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2)
     @dataset.filter([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE ((id1 != id1) AND (id2 != id2))"
-    d1.instance_variable_get(:@sql_used).should == "SELECT id1, id2 FROM test WHERE (region = 'Asia')"
-    d1.instance_variable_set(:@sql_used, nil)
-    @dataset.exclude([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (1 = 1)"
-    d1.instance_variable_get(:@sql_used).should == "SELECT id1, id2 FROM test WHERE (region = 'Asia')"
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+    @dataset.exclude([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE ((id1 = id1) AND (id2 = id2))"
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+  end
+  
+  specify "should handle IN/NOT IN queries with multiple columns and an empty dataset where the database doesn't support it with correct NULL handling" do
+    begin
+      Sequel.empty_array_handle_nulls = false
+      @dataset.meta_def(:supports_multiple_column_in?){false}
+      db = Sequel.mock
+      d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2)
+      @dataset.filter([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (1 = 0)"
+      db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+      @dataset.exclude([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (1 = 1)"
+      db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+    ensure
+      Sequel.empty_array_handle_nulls = true
+    end
+  end
+  
+  specify "should handle IN/NOT IN queries for datasets with row_procs" do
+    @dataset.meta_def(:supports_multiple_column_in?){false}
+    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}
+    @dataset.filter([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (((id1 = 1) AND (id2 = 2)) OR ((id1 = 3) AND (id2 = 4)))"
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+    @dataset.exclude([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (((id1 != 1) OR (id2 != 2)) AND ((id1 != 3) OR (id2 != 4)))"
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
   end
   
   specify "should accept a subquery for an EXISTS clause" do
@@ -601,10 +613,18 @@ describe "Dataset#where" do
   end
 
   specify "should accept true and false as arguments" do
-    @dataset.filter(true).sql.should ==
-      "SELECT * FROM test WHERE 't'"
-    @dataset.filter(false).sql.should ==
-      "SELECT * FROM test WHERE 'f'"
+    @dataset.filter(true).sql.should == "SELECT * FROM test WHERE 't'"
+    @dataset.filter(Sequel::SQLTRUE).sql.should == "SELECT * FROM test WHERE 't'"
+    @dataset.filter(false).sql.should == "SELECT * FROM test WHERE 'f'"
+    @dataset.filter(Sequel::SQLFALSE).sql.should == "SELECT * FROM test WHERE 'f'"
+  end
+
+  specify "should use boolean expression if dataset does not support where true/false" do
+    def @dataset.supports_where_true?() false end
+    @dataset.filter(true).sql.should == "SELECT * FROM test WHERE (1 = 1)"
+    @dataset.filter(Sequel::SQLTRUE).sql.should == "SELECT * FROM test WHERE (1 = 1)"
+    @dataset.filter(false).sql.should == "SELECT * FROM test WHERE (1 = 0)"
+    @dataset.filter(Sequel::SQLFALSE).sql.should == "SELECT * FROM test WHERE (1 = 0)"
   end
 
   specify "should allow the use of multiple arguments" do
@@ -658,33 +678,25 @@ describe "Dataset#or" do
   end
   
   specify "should add an alternative expression to the where clause" do
-    @d1.or(:y => 2).sql.should == 
-      'SELECT * FROM test WHERE ((x = 1) OR (y = 2))'
+    @d1.or(:y => 2).sql.should == 'SELECT * FROM test WHERE ((x = 1) OR (y = 2))'
   end
   
   specify "should accept all forms of filters" do
-    @d1.or('y > ?', 2).sql.should ==
-      'SELECT * FROM test WHERE ((x = 1) OR (y > 2))'
-    @d1.or(:yy.sql_number > 3).sql.should ==
-      'SELECT * FROM test WHERE ((x = 1) OR (yy > 3))'
+    @d1.or('y > ?', 2).sql.should == 'SELECT * FROM test WHERE ((x = 1) OR (y > 2))'
+    @d1.or(:yy.sql_number > 3).sql.should == 'SELECT * FROM test WHERE ((x = 1) OR (yy > 3))'
   end    
 
   specify "should accept blocks passed to filter" do
-    @d1.or{:yy.sql_number > 3}.sql.should ==
-      'SELECT * FROM test WHERE ((x = 1) OR (yy > 3))'
+    @d1.or{:yy.sql_number > 3}.sql.should == 'SELECT * FROM test WHERE ((x = 1) OR (yy > 3))'
   end
   
   specify "should correctly add parens to give predictable results" do
-    @d1.filter(:y => 2).or(:z => 3).sql.should == 
-      'SELECT * FROM test WHERE (((x = 1) AND (y = 2)) OR (z = 3))'
-
-    @d1.or(:y => 2).filter(:z => 3).sql.should == 
-      'SELECT * FROM test WHERE (((x = 1) OR (y = 2)) AND (z = 3))'
+    @d1.filter(:y => 2).or(:z => 3).sql.should == 'SELECT * FROM test WHERE (((x = 1) AND (y = 2)) OR (z = 3))'
+    @d1.or(:y => 2).filter(:z => 3).sql.should == 'SELECT * FROM test WHERE (((x = 1) OR (y = 2)) AND (z = 3))'
   end
 
   specify "should allow the use of blocks and arguments simultaneously" do
-    @d1.or(:zz.sql_number < 3){:yy.sql_number > 3}.sql.should ==
-      'SELECT * FROM test WHERE ((x = 1) OR ((zz < 3) AND (yy > 3)))'
+    @d1.or(:zz.sql_number < 3){:yy.sql_number > 3}.sql.should == 'SELECT * FROM test WHERE ((x = 1) OR ((zz < 3) AND (yy > 3)))'
   end
 end
 
@@ -697,34 +709,25 @@ describe "Dataset#and" do
   specify "should raise if no filter exists" do
     proc {@dataset.and(:a => 1)}.should raise_error(Sequel::Error)
     proc {@dataset.where(:a => 1).group(:t).and(:b => 2)}.should_not raise_error(Sequel::Error)
-    @dataset.where(:a => 1).group(:t).and(:b => 2).sql ==
-      "SELECT * FROM test WHERE (a = 1) AND (b = 2) GROUP BY t"
+    @dataset.where(:a => 1).group(:t).and(:b => 2).sql == "SELECT * FROM test WHERE (a = 1) AND (b = 2) GROUP BY t"
   end
   
   specify "should add an alternative expression to the where clause" do
-    @d1.and(:y => 2).sql.should == 
-      'SELECT * FROM test WHERE ((x = 1) AND (y = 2))'
+    @d1.and(:y => 2).sql.should == 'SELECT * FROM test WHERE ((x = 1) AND (y = 2))'
   end
   
-  specify "should accept all forms of filters" do
-    # probably not exhaustive, but good enough
-    @d1.and('y > ?', 2).sql.should ==
-      'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
-    @d1.and(:yy.sql_number > 3).sql.should ==
-      'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
+  specify "should accept different types of filters" do
+    @d1.and('y > ?', 2).sql.should == 'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
+    @d1.and(:yy.sql_number > 3).sql.should == 'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
   end
       
   specify "should accept blocks passed to filter" do
-    @d1.and {:yy.sql_number > 3}.sql.should ==
-      'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
+    @d1.and {:yy.sql_number > 3}.sql.should == 'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
   end
   
   specify "should correctly add parens to give predictable results" do
-    @d1.or(:y => 2).and(:z => 3).sql.should == 
-      'SELECT * FROM test WHERE (((x = 1) OR (y = 2)) AND (z = 3))'
-
-    @d1.and(:y => 2).or(:z => 3).sql.should == 
-      'SELECT * FROM test WHERE (((x = 1) AND (y = 2)) OR (z = 3))'
+    @d1.or(:y => 2).and(:z => 3).sql.should == 'SELECT * FROM test WHERE (((x = 1) OR (y = 2)) AND (z = 3))'
+    @d1.and(:y => 2).or(:z => 3).sql.should == 'SELECT * FROM test WHERE (((x = 1) AND (y = 2)) OR (z = 3))'
   end
 end
 
@@ -734,8 +737,11 @@ describe "Dataset#exclude" do
   end
 
   specify "should correctly negate the expression when one condition is given" do
-    @dataset.exclude(:region=>'Asia').select_sql.should ==
-      "SELECT * FROM test WHERE (region != 'Asia')"
+    @dataset.exclude(:region=>'Asia').select_sql.should == "SELECT * FROM test WHERE (region != 'Asia')"
+  end
+
+  specify "should affect the having clause if having clause is already used" do
+    @dataset.group_and_count(:name).having{count > 2}.exclude{count > 5}.sql.should == "SELECT name, count(*) AS count FROM test GROUP BY name HAVING ((count > 2) AND (count <= 5))"
   end
 
   specify "should take multiple conditions as a hash and express the logic correctly in SQL" do
@@ -745,30 +751,46 @@ describe "Dataset#exclude" do
   end
 
   specify "should parenthesize a single string condition correctly" do
-    @dataset.exclude("region = 'Asia' AND name = 'Japan'").select_sql.should ==
-      "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
+    @dataset.exclude("region = 'Asia' AND name = 'Japan'").select_sql.should == "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
   end
 
   specify "should parenthesize an array condition correctly" do
-    @dataset.exclude('region = ? AND name = ?', 'Asia', 'Japan').select_sql.should ==
-      "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
+    @dataset.exclude('region = ? AND name = ?', 'Asia', 'Japan').select_sql.should == "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
   end
 
   specify "should correctly parenthesize when it is used twice" do
-    @dataset.exclude(:region => 'Asia').exclude(:name => 'Japan').select_sql.should ==
-      "SELECT * FROM test WHERE ((region != 'Asia') AND (name != 'Japan'))"
+    @dataset.exclude(:region => 'Asia').exclude(:name => 'Japan').select_sql.should == "SELECT * FROM test WHERE ((region != 'Asia') AND (name != 'Japan'))"
   end
   
   specify "should support proc expressions" do
-    @dataset.exclude{:id.sql_number < 6}.sql.should == 
-      'SELECT * FROM test WHERE (id >= 6)'
+    @dataset.exclude{:id.sql_number < 6}.sql.should == 'SELECT * FROM test WHERE (id >= 6)'
   end
   
   specify "should allow the use of blocks and arguments simultaneously" do
-    @dataset.exclude(:id => (7..11)){:id.sql_number < 6}.sql.should == 
-      'SELECT * FROM test WHERE ((id < 7) OR (id > 11) OR (id >= 6))'
-    @dataset.exclude([:id, 1], [:x, 3]){:id.sql_number < 6}.sql.should == 
-      'SELECT * FROM test WHERE ((id != 1) OR (x != 3) OR (id >= 6))'
+    @dataset.exclude(:id => (7..11)){:id.sql_number < 6}.sql.should == 'SELECT * FROM test WHERE ((id < 7) OR (id > 11) OR (id >= 6))'
+    @dataset.exclude([:id, 1], [:x, 3]){:id.sql_number < 6}.sql.should == 'SELECT * FROM test WHERE ((id != 1) OR (x != 3) OR (id >= 6))'
+  end
+end
+
+describe "Dataset#exclude_where" do
+  before do
+    @dataset = Sequel::Dataset.new(nil).from(:test)
+  end
+
+  specify "should correctly negate the expression and add it to the where clause" do
+    @dataset.exclude_where(:region=>'Asia').sql.should == "SELECT * FROM test WHERE (region != 'Asia')"
+    @dataset.exclude_where(:region=>'Asia').exclude_where(:region=>'NA').sql.should == "SELECT * FROM test WHERE ((region != 'Asia') AND (region != 'NA'))"
+  end
+
+  specify "should affect the where clause even if having clause is already used" do
+    @dataset.group_and_count(:name).having{count > 2}.exclude_where(:region=>'Asia').sql.should ==
+      "SELECT name, count(*) AS count FROM test WHERE (region != 'Asia') GROUP BY name HAVING (count > 2)"
+  end
+end
+
+describe "Dataset#exclude_having" do
+  specify "should correctly negate the expression and add it to the having clause" do
+    Sequel::Dataset.new(nil).from(:test).exclude_having{count > 2}.exclude_having{count < 0}.sql.should == "SELECT * FROM test HAVING ((count <= 2) AND (count >= 0))"
   end
 end
 
@@ -794,9 +816,6 @@ describe "Dataset#having" do
   before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
     @grouped = @dataset.group(:region).select(:region, :sum.sql_function(:population), :avg.sql_function(:gdp))
-    @d1 = @grouped.having('sum(population) > 10')
-    @d2 = @grouped.having(:region => 'Asia')
-    @columns = "region, sum(population), avg(gdp)"
   end
 
   specify "should just clone if given an empty argument" do
@@ -806,18 +825,15 @@ describe "Dataset#having" do
   end
   
   specify "should affect select statements" do
-    @d1.select_sql.should ==
-      "SELECT #{@columns} FROM test GROUP BY region HAVING (sum(population) > 10)"
+    @grouped.having('sum(population) > 10').select_sql.should == "SELECT region, sum(population), avg(gdp) FROM test GROUP BY region HAVING (sum(population) > 10)"
   end
 
   specify "should support proc expressions" do
-    @grouped.having {:sum.sql_function(:population) > 10}.sql.should == 
-      "SELECT #{@columns} FROM test GROUP BY region HAVING (sum(population) > 10)"
+    @grouped.having {:sum.sql_function(:population) > 10}.sql.should == "SELECT region, sum(population), avg(gdp) FROM test GROUP BY region HAVING (sum(population) > 10)"
   end
 
   specify "should work with and on the having clause" do
-    @grouped.having( :a.sql_number > 1 ).and( :b.sql_number < 2 ).sql.should ==
-      "SELECT #{@columns} FROM test GROUP BY region HAVING ((a > 1) AND (b < 2))"
+    @grouped.having( :a.sql_number > 1 ).and( :b.sql_number < 2 ).sql.should == "SELECT region, sum(population), avg(gdp) FROM test GROUP BY region HAVING ((a > 1) AND (b < 2))"
   end
 end
 
@@ -848,7 +864,7 @@ describe "a grouped dataset" do
   end
   
   specify "should format the right statement for counting (as a subquery)" do
-    db = MockDatabase.new
+    db = Sequel.mock
     db[:test].select(:name).group(:name).count
     db.sqls.should == ["SELECT COUNT(*) AS count FROM (SELECT name FROM test GROUP BY name) AS t1 LIMIT 1"]
   end
@@ -856,7 +872,7 @@ end
 
 describe "Dataset#group_by" do
   before do
-    @dataset = Sequel::Dataset.new(nil).from(:test).group_by(:type_id)
+    @dataset = Sequel.mock[:test].group_by(:type_id)
   end
 
   specify "should raise when trying to generate an update statement" do
@@ -868,45 +884,60 @@ describe "Dataset#group_by" do
   end
 
   specify "should specify the grouping in generated select statement" do
-    @dataset.select_sql.should ==
-      "SELECT * FROM test GROUP BY type_id"
-    @dataset.group_by(:a, :b).select_sql.should ==
-      "SELECT * FROM test GROUP BY a, b"
-    @dataset.group_by(:type_id=>nil).select_sql.should ==
-      "SELECT * FROM test GROUP BY (type_id IS NULL)"
+    @dataset.select_sql.should == "SELECT * FROM test GROUP BY type_id"
+    @dataset.group_by(:a, :b).select_sql.should == "SELECT * FROM test GROUP BY a, b"
+    @dataset.group_by(:type_id=>nil).select_sql.should == "SELECT * FROM test GROUP BY (type_id IS NULL)"
   end
 
-  specify "should ungroup when passed nil, empty, or no arguments" do
-    @dataset.group_by.select_sql.should ==
-      "SELECT * FROM test"
-    @dataset.group_by(nil).select_sql.should ==
-      "SELECT * FROM test"
+  specify "should ungroup when passed nil or no arguments" do
+    @dataset.group_by.select_sql.should == "SELECT * FROM test"
+    @dataset.group_by(nil).select_sql.should == "SELECT * FROM test"
   end
 
   specify "should undo previous grouping" do
-    @dataset.group_by(:a).group_by(:b).select_sql.should ==
-      "SELECT * FROM test GROUP BY b"
-    @dataset.group_by(:a, :b).group_by.select_sql.should ==
-      "SELECT * FROM test"
+    @dataset.group_by(:a).group_by(:b).select_sql.should == "SELECT * FROM test GROUP BY b"
+    @dataset.group_by(:a, :b).group_by.select_sql.should == "SELECT * FROM test"
   end
 
   specify "should be aliased as #group" do
-    @dataset.group(:type_id=>nil).select_sql.should ==
-      "SELECT * FROM test GROUP BY (type_id IS NULL)"
+    @dataset.group(:type_id=>nil).select_sql.should == "SELECT * FROM test GROUP BY (type_id IS NULL)"
+  end
+
+  specify "should take a virtual row block" do
+    @dataset.group{type_id > 1}.sql.should == "SELECT * FROM test GROUP BY (type_id > 1)"
+    @dataset.group_by{type_id > 1}.sql.should == "SELECT * FROM test GROUP BY (type_id > 1)"
+    @dataset.group{[type_id > 1, type_id < 2]}.sql.should == "SELECT * FROM test GROUP BY (type_id > 1), (type_id < 2)"
+    @dataset.group(:foo){type_id > 1}.sql.should == "SELECT * FROM test GROUP BY foo, (type_id > 1)"
+  end
+
+  specify "should support a #group_rollup method if the database supports it" do
+    @dataset.meta_def(:supports_group_rollup?){true}
+    @dataset.group(:type_id).group_rollup.select_sql.should == "SELECT * FROM test GROUP BY ROLLUP(type_id)"
+    @dataset.group(:type_id, :b).group_rollup.select_sql.should == "SELECT * FROM test GROUP BY ROLLUP(type_id, b)"
+  end
+
+  specify "should support a #group_cube method if the database supports it" do
+    @dataset.meta_def(:supports_group_cube?){true}
+    @dataset.group(:type_id).group_cube.select_sql.should == "SELECT * FROM test GROUP BY CUBE(type_id)"
+    @dataset.group(:type_id, :b).group_cube.select_sql.should == "SELECT * FROM test GROUP BY CUBE(type_id, b)"
+  end
+
+  specify "should have #group_cube and #group_rollup methods raise an Error if not supported it" do
+    proc{@dataset.group(:type_id).group_rollup}.should raise_error(Sequel::Error)
+    proc{@dataset.group(:type_id).group_cube}.should raise_error(Sequel::Error)
   end
 end
 
 describe "Dataset#as" do
   specify "should set up an alias" do
     dataset = Sequel::Dataset.new(nil).from(:test)
-    dataset.select(dataset.limit(1).select(:name).as(:n)).sql.should == \
-      'SELECT (SELECT name FROM test LIMIT 1) AS n FROM test'
+    dataset.select(dataset.limit(1).select(:name).as(:n)).sql.should == 'SELECT (SELECT name FROM test LIMIT 1) AS n FROM test'
   end
 end
 
 describe "Dataset#literal" do
   before do
-    @dataset = Sequel::Dataset.new(nil).from(:test)
+    @dataset = Sequel::Database.new.from(:test)
   end
   
   specify "should escape strings properly" do
@@ -944,6 +975,21 @@ describe "Dataset#literal" do
     @dataset.literal(:"items__na#m$e").should == "items.na#m$e"
   end
 
+  specify "should call sql_literal_append with dataset and sql on type if not natively supported and the object responds to it" do
+    @a = Class.new do
+      def sql_literal_append(ds, sql)
+        sql << "called #{ds.blah}"
+      end
+      def sql_literal(ds)
+        "not called #{ds.blah}"
+      end
+    end
+    def @dataset.blah
+      "ds"
+    end
+    @dataset.literal(@a.new).should == "called ds"
+  end
+  
   specify "should call sql_literal with dataset on type if not natively supported and the object responds to it" do
     @a = Class.new do
       def sql_literal(ds)
@@ -965,6 +1011,12 @@ describe "Dataset#literal" do
     d.literal(d).should == "(#{d.sql})"
   end
   
+  specify "should literalize Sequel::SQLTime properly" do
+    t = Sequel::SQLTime.now
+    s = t.strftime("'%H:%M:%S")
+    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.usec)}'"
+  end
+  
   specify "should literalize Time properly" do
     t = Time.now
     s = t.strftime("'%Y-%m-%d %H:%M:%S")
@@ -1041,10 +1093,9 @@ describe "Dataset#literal" do
   end
   
   specify "should not modify literal strings" do
+    @dataset.quote_identifiers = true
     @dataset.literal('col1 + 2'.lit).should == 'col1 + 2'
-    
-    @dataset.update_sql(:a => 'a + 2'.lit).should == 
-      'UPDATE test SET a = a + 2'
+    @dataset.update_sql(Sequel::SQL::Identifier.new('a'.lit) => 'a + 2'.lit).should == 'UPDATE "test" SET a = a + 2'
   end
 
   specify "should literalize BigDecimal instances correctly" do
@@ -1069,35 +1120,25 @@ describe "Dataset#from" do
   end
 
   specify "should format a Dataset as a subquery if it has had options set" do
-    @dataset.from(@dataset.from(:a).where(:a=>1)).select_sql.should ==
-      "SELECT * FROM (SELECT * FROM a WHERE (a = 1)) AS t1"
+    @dataset.from(@dataset.from(:a).where(:a=>1)).select_sql.should == "SELECT * FROM (SELECT * FROM a WHERE (a = 1)) AS t1"
   end
   
   specify "should automatically alias sub-queries" do
-    @dataset.from(@dataset.from(:a).group(:b)).select_sql.should ==
-      "SELECT * FROM (SELECT * FROM a GROUP BY b) AS t1"
+    @dataset.from(@dataset.from(:a).group(:b)).select_sql.should == "SELECT * FROM (SELECT * FROM a GROUP BY b) AS t1"
       
     d1 = @dataset.from(:a).group(:b)
     d2 = @dataset.from(:c).group(:d)
-    
-    @dataset.from(d1, d2).sql.should == 
-      "SELECT * FROM (SELECT * FROM a GROUP BY b) AS t1, (SELECT * FROM c GROUP BY d) AS t2"
+    @dataset.from(d1, d2).sql.should == "SELECT * FROM (SELECT * FROM a GROUP BY b) AS t1, (SELECT * FROM c GROUP BY d) AS t2"
   end
   
   specify "should accept a hash for aliasing" do
-    @dataset.from(:a => :b).sql.should ==
-      "SELECT * FROM a AS b"
-      
-    @dataset.from(:a => 'b').sql.should ==
-      "SELECT * FROM a AS b"
-
-    @dataset.from(@dataset.from(:a).group(:b) => :c).sql.should ==
-      "SELECT * FROM (SELECT * FROM a GROUP BY b) AS c"
+    @dataset.from(:a => :b).sql.should == "SELECT * FROM a AS b"
+    @dataset.from(:a => 'b').sql.should == "SELECT * FROM a AS b"
+    @dataset.from(@dataset.from(:a).group(:b) => :c).sql.should == "SELECT * FROM (SELECT * FROM a GROUP BY b) AS c"
   end
 
   specify "should always use a subquery if given a dataset" do
-    @dataset.from(@dataset.from(:a)).select_sql.should ==
-      "SELECT * FROM (SELECT * FROM a) AS t1"
+    @dataset.from(@dataset.from(:a)).select_sql.should == "SELECT * FROM (SELECT * FROM a) AS t1"
   end
   
   specify "should remove all FROM tables if called with no arguments" do
@@ -1105,32 +1146,31 @@ describe "Dataset#from" do
   end
   
   specify "should accept sql functions" do
-    @dataset.from(:abc.sql_function(:def)).select_sql.should ==
-      "SELECT * FROM abc(def)"
-    
-    @dataset.from(:a.sql_function(:i)).select_sql.should ==
-      "SELECT * FROM a(i)"
+    @dataset.from(:abc.sql_function(:def)).select_sql.should == "SELECT * FROM abc(def)"
+    @dataset.from(:a.sql_function(:i)).select_sql.should == "SELECT * FROM a(i)"
   end
 
   specify "should accept :schema__table___alias symbol format" do
-    @dataset.from(:abc__def).select_sql.should ==
-      "SELECT * FROM abc.def"
-    @dataset.from(:a_b__c).select_sql.should ==
-      "SELECT * FROM a_b.c"
-    @dataset.from(:'#__#').select_sql.should ==
-      'SELECT * FROM #.#'
-    @dataset.from(:abc__def___d).select_sql.should ==
-      "SELECT * FROM abc.def AS d"
-    @dataset.from(:a_b__d_e___f_g).select_sql.should ==
-      "SELECT * FROM a_b.d_e AS f_g"
-    @dataset.from(:'#__#___#').select_sql.should ==
-      'SELECT * FROM #.# AS #'
-    @dataset.from(:abc___def).select_sql.should ==
-      "SELECT * FROM abc AS def"
-    @dataset.from(:a_b___c_d).select_sql.should ==
-      "SELECT * FROM a_b AS c_d"
-    @dataset.from(:'#___#').select_sql.should ==
-      'SELECT * FROM # AS #'
+    @dataset.from(:abc__def).select_sql.should == "SELECT * FROM abc.def"
+    @dataset.from(:a_b__c).select_sql.should == "SELECT * FROM a_b.c"
+    @dataset.from(:'#__#').select_sql.should == 'SELECT * FROM #.#'
+    @dataset.from(:abc__def___d).select_sql.should == "SELECT * FROM abc.def AS d"
+    @dataset.from(:a_b__d_e___f_g).select_sql.should == "SELECT * FROM a_b.d_e AS f_g"
+    @dataset.from(:'#__#___#').select_sql.should == 'SELECT * FROM #.# AS #'
+    @dataset.from(:abc___def).select_sql.should == "SELECT * FROM abc AS def"
+    @dataset.from(:a_b___c_d).select_sql.should == "SELECT * FROM a_b AS c_d"
+    @dataset.from(:'#___#').select_sql.should == 'SELECT * FROM # AS #'
+  end
+
+  specify "should not handle :foo__schema__table___alias specially" do
+    @dataset.from(:foo__schema__table___alias).select_sql.should == "SELECT * FROM foo.schema__table AS alias"
+  end
+
+  specify "should hoist WITH clauses from subqueries if the dataset doesn't support CTEs in subselects" do
+    @dataset.meta_def(:supports_cte?){true}
+    @dataset.meta_def(:supports_cte_in_subselect?){false}
+    @dataset.from(@dataset.from(:a).with(:a, @dataset.from(:b))).sql.should == '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.should == 'WITH a AS (SELECT * FROM b), c AS (SELECT * FROM d) SELECT * FROM (SELECT * FROM a) AS t1, (SELECT * FROM c) AS t2'
   end
 end
 
@@ -1147,18 +1187,17 @@ describe "Dataset#select" do
   specify "should accept symbols and literal strings" do
     @d.select('aaa'.lit).sql.should == 'SELECT aaa FROM test'
     @d.select(:a, 'b'.lit).sql.should == 'SELECT a, b FROM test'
-    @d.select(:test__cc, 'test.d AS e'.lit).sql.should == 
-      'SELECT test.cc, test.d AS e FROM test'
-    @d.select('test.d AS e'.lit, :test__cc).sql.should == 
-      'SELECT test.d AS e, test.cc FROM test'
-
-    # symbol helpers      
-    @d.select(:test.*).sql.should ==
-      'SELECT test.* FROM test'
-    @d.select(:test__name.as(:n)).sql.should ==
-      'SELECT test.name AS n FROM test'
-    @d.select(:test__name___n).sql.should ==
-      'SELECT test.name AS n FROM test'
+    @d.select(:test__cc, 'test.d AS e'.lit).sql.should == 'SELECT test.cc, test.d AS e FROM test'
+    @d.select('test.d AS e'.lit, :test__cc).sql.should == 'SELECT test.d AS e, test.cc FROM test'
+    @d.select(:test__name___n).sql.should == 'SELECT test.name AS n FROM test'
+  end
+  
+  specify "should accept ColumnAlls" do
+    @d.select(:test.*).sql.should == 'SELECT test.* FROM test'
+  end
+  
+  specify "should accept QualifiedIdentifiers" do
+    @d.select(:test__name.as(:n)).sql.should == 'SELECT test.name AS n FROM test'
   end
 
   specify "should use the wildcard if no arguments are given" do
@@ -1166,20 +1205,17 @@ describe "Dataset#select" do
   end
   
   specify "should accept a hash for AS values" do
-    @d.select(:name => 'n', :__ggh => 'age').sql.should =~
-      /SELECT ((name AS n, __ggh AS age)|(__ggh AS age, name AS n)) FROM test/
+    @d.select(:name => 'n', :__ggh => 'age').sql.should =~ /SELECT ((name AS n, __ggh AS age)|(__ggh AS age, name AS n)) FROM test/
   end
 
-  specify "should overrun the previous select option" do
+  specify "should override the previous select option" do
     @d.select!(:a, :b, :c).select.sql.should == 'SELECT * FROM test'
     @d.select!(:price).select(:name).sql.should == 'SELECT name FROM test'
   end
   
   specify "should accept arbitrary objects and literalize them correctly" do
     @d.select(1, :a, 't').sql.should == "SELECT 1, a, 't' FROM test"
-
     @d.select(nil, :sum.sql_function(:t), :x___y).sql.should == "SELECT NULL, sum(t), x AS y FROM test"
-
     @d.select(nil, 1, :x => :y).sql.should == "SELECT NULL, 1, x AS y FROM test"
   end
 
@@ -1198,6 +1234,27 @@ describe "Dataset#select" do
   end
 end
 
+describe "Dataset#select_group" do
+  before do
+    @d = Sequel::Dataset.new(nil).from(:test)
+  end
+
+  specify "should set both SELECT and GROUP" do
+    @d.select_group(:name).sql.should == 'SELECT name FROM test GROUP BY name'
+    @d.select_group(:a, :b__c, :d___e).sql.should == 'SELECT a, b.c, d AS e FROM test GROUP BY a, b.c, d'
+  end
+
+  specify "should remove from both SELECT and GROUP if no arguments" do
+    @d.select_group(:name).select_group.sql.should == 'SELECT * FROM test'
+  end
+
+  specify "should accept virtual row blocks" do
+    @d.select_group{name}.sql.should == 'SELECT name FROM test GROUP BY name'
+    @d.select_group{[name, f(v).as(a)]}.sql.should == 'SELECT name, f(v) AS a FROM test GROUP BY name, f(v)'
+    @d.select_group(:name){f(v).as(a)}.sql.should == 'SELECT name, f(v) AS a FROM test GROUP BY name, f(v)'
+  end
+end
+  
 describe "Dataset#select_all" do
   before do
     @d = Sequel::Dataset.new(nil).from(:test)
@@ -1207,9 +1264,43 @@ describe "Dataset#select_all" do
     @d.select_all.sql.should == 'SELECT * FROM test'
   end
   
-  specify "should overrun the previous select option" do
+  specify "should override the previous select option" do
     @d.select!(:a, :b, :c).select_all.sql.should == 'SELECT * FROM test'
   end
+
+  specify "should select all columns in a table if given an argument" do
+    @d.select_all(:test).sql.should == 'SELECT test.* FROM test'
+  end
+  
+  specify "should select all columns all tables if given a multiple arguments" do
+    @d.select_all(:test, :foo).sql.should == 'SELECT test.*, foo.* FROM test'
+  end
+  
+  specify "should work correctly with qualified symbols" do
+    @d.select_all(:sch__test).sql.should == 'SELECT sch.test.* FROM test'
+  end
+  
+  specify "should work correctly with aliased symbols" do
+    @d.select_all(:test___al).sql.should == 'SELECT al.* FROM test'
+    @d.select_all(:sch__test___al).sql.should == 'SELECT al.* FROM test'
+  end
+  
+  specify "should work correctly with SQL::Identifiers" do
+    @d.select_all(:test.identifier).sql.should == 'SELECT test.* FROM test'
+  end
+  
+  specify "should work correctly with SQL::QualifiedIdentifier" do
+    @d.select_all(:test.qualify(:sch)).sql.should == 'SELECT sch.test.* FROM test'
+  end
+  
+  specify "should work correctly with SQL::AliasedExpressions" do
+    @d.select_all(:test.as(:al)).sql.should == 'SELECT al.* FROM test'
+  end
+  
+  specify "should work correctly with SQL::JoinClauses" do
+    d = @d.cross_join(:foo).cross_join(:test___al)
+    @d.select_all(*d.opts[:join]).sql.should == 'SELECT foo.*, al.* FROM test'
+  end
 end
 
 describe "Dataset#select_more" do
@@ -1254,6 +1345,14 @@ describe "Dataset#select_append" do
     @d.select(:a).select_append{|o| o.b}.sql.should == 'SELECT a, b FROM test'
     @d.select(:a.*).select_append(:b.*){b(1)}.sql.should == 'SELECT a.*, b.*, b(1) FROM test'
   end
+
+  specify "should select from all from and join tables if SELECT *, column not supported" do
+    @d.meta_def(:supports_select_all_and_column?){false}
+    @d.select_append(:b).sql.should == 'SELECT test.*, b FROM test'
+    @d.from(:test, :c).select_append(:b).sql.should == 'SELECT test.*, c.*, b FROM test, c'
+    @d.cross_join(:c).select_append(:b).sql.should == 'SELECT test.*, c.*, b FROM test CROSS JOIN c'
+    @d.cross_join(:c).cross_join(:d).select_append(:b).sql.should == 'SELECT test.*, c.*, d.*, b FROM test CROSS JOIN c CROSS JOIN d'
+  end
 end
 
 describe "Dataset#order" do
@@ -1262,38 +1361,31 @@ describe "Dataset#order" do
   end
   
   specify "should include an ORDER BY clause in the select statement" do
-    @dataset.order(:name).sql.should == 
-      'SELECT * FROM test ORDER BY name'
+    @dataset.order(:name).sql.should == 'SELECT * FROM test ORDER BY name'
   end
   
   specify "should accept multiple arguments" do
-    @dataset.order(:name, :price.desc).sql.should ==
-      'SELECT * FROM test ORDER BY name, price DESC'
+    @dataset.order(:name, :price.desc).sql.should == 'SELECT * FROM test ORDER BY name, price DESC'
   end
   
   specify "should accept :nulls options for asc and desc" do
-    @dataset.order(:name.asc(:nulls=>:last), :price.desc(:nulls=>:first)).sql.should ==
-      'SELECT * FROM test ORDER BY name ASC NULLS LAST, price DESC NULLS FIRST'
+    @dataset.order(:name.asc(:nulls=>:last), :price.desc(:nulls=>:first)).sql.should == 'SELECT * FROM test ORDER BY name ASC NULLS LAST, price DESC NULLS FIRST'
   end
   
-  specify "should overrun a previous ordering" do
-    @dataset.order(:name).order(:stamp).sql.should ==
-      'SELECT * FROM test ORDER BY stamp'
+  specify "should override a previous ordering" do
+    @dataset.order(:name).order(:stamp).sql.should == 'SELECT * FROM test ORDER BY stamp'
   end
   
   specify "should accept a literal string" do
-    @dataset.order('dada ASC'.lit).sql.should ==
-      'SELECT * FROM test ORDER BY dada ASC'
+    @dataset.order('dada ASC'.lit).sql.should == 'SELECT * FROM test ORDER BY dada ASC'
   end
   
   specify "should accept a hash as an expression" do
-    @dataset.order(:name=>nil).sql.should ==
-      'SELECT * FROM test ORDER BY (name IS NULL)'
+    @dataset.order(:name=>nil).sql.should == 'SELECT * FROM test ORDER BY (name IS NULL)'
   end
   
   specify "should accept a nil to remove ordering" do
-    @dataset.order(:bah).order(nil).sql.should == 
-      'SELECT * FROM test'
+    @dataset.order(:bah).order(nil).sql.should == 'SELECT * FROM test'
   end
 
   specify "should accept a block that yields a virtual row" do
@@ -1355,6 +1447,13 @@ describe "Dataset#with_sql" do
   specify "should keep row_proc" do
     @dataset.with_sql('SELECT 1 FROM test').row_proc.should == @dataset.row_proc
   end
+
+  specify "should work with method symbols and arguments" do
+    @dataset.with_sql(:delete_sql).sql.should == 'DELETE FROM test'
+    @dataset.with_sql(:insert_sql, :b=>1).sql.should == 'INSERT INTO test (b) VALUES (1)'
+    @dataset.with_sql(:update_sql, :b=>1).sql.should == 'UPDATE test SET b = 1'
+  end
+  
 end
 
 describe "Dataset#order_by" do
@@ -1363,28 +1462,23 @@ describe "Dataset#order_by" do
   end
   
   specify "should include an ORDER BY clause in the select statement" do
-    @dataset.order_by(:name).sql.should == 
-      'SELECT * FROM test ORDER BY name'
+    @dataset.order_by(:name).sql.should == 'SELECT * FROM test ORDER BY name'
   end
   
   specify "should accept multiple arguments" do
-    @dataset.order_by(:name, :price.desc).sql.should ==
-      'SELECT * FROM test ORDER BY name, price DESC'
+    @dataset.order_by(:name, :price.desc).sql.should == 'SELECT * FROM test ORDER BY name, price DESC'
   end
   
-  specify "should overrun a previous ordering" do
-    @dataset.order_by(:name).order(:stamp).sql.should ==
-      'SELECT * FROM test ORDER BY stamp'
+  specify "should override a previous ordering" do
+    @dataset.order_by(:name).order(:stamp).sql.should == 'SELECT * FROM test ORDER BY stamp'
   end
   
   specify "should accept a string" do
-    @dataset.order_by('dada ASC'.lit).sql.should ==
-      'SELECT * FROM test ORDER BY dada ASC'
+    @dataset.order_by('dada ASC'.lit).sql.should == 'SELECT * FROM test ORDER BY dada ASC'
   end
 
   specify "should accept a nil to remove ordering" do
-    @dataset.order_by(:bah).order_by(nil).sql.should == 
-      'SELECT * FROM test'
+    @dataset.order_by(:bah).order_by(nil).sql.should == 'SELECT * FROM test'
   end
 end
 
@@ -1417,13 +1511,11 @@ describe "Dataset#order_prepend" do
   end
   
   specify "should include an ORDER BY clause in the select statement" do
-    @dataset.order_prepend(:name).sql.should == 
-      'SELECT * FROM test ORDER BY name'
+    @dataset.order_prepend(:name).sql.should == 'SELECT * FROM test ORDER BY name'
   end
   
   specify "should add to the beginning of a previous ordering" do
-    @dataset.order(:name).order_prepend(:stamp.desc).sql.should ==
-      'SELECT * FROM test ORDER BY stamp DESC, name'
+    @dataset.order(:name).order_prepend(:stamp.desc).sql.should == 'SELECT * FROM test ORDER BY stamp DESC, name'
   end
 
   specify "should accept a block that yields a virtual row" do
@@ -1438,45 +1530,36 @@ describe "Dataset#reverse_order" do
   end
   
   specify "should use DESC as default order" do
-    @dataset.reverse_order(:name).sql.should == 
-      'SELECT * FROM test ORDER BY name DESC'
+    @dataset.reverse_order(:name).sql.should == 'SELECT * FROM test ORDER BY name DESC'
   end
   
   specify "should invert the order given" do
-    @dataset.reverse_order(:name.desc).sql.should ==
-      'SELECT * FROM test ORDER BY name ASC'
+    @dataset.reverse_order(:name.desc).sql.should == 'SELECT * FROM test ORDER BY name ASC'
   end
   
   specify "should invert the order for ASC expressions" do
-    @dataset.reverse_order(:name.asc).sql.should ==
-      'SELECT * FROM test ORDER BY name DESC'
+    @dataset.reverse_order(:name.asc).sql.should == 'SELECT * FROM test ORDER BY name DESC'
   end
   
   specify "should accept multiple arguments" do
-    @dataset.reverse_order(:name, :price.desc).sql.should ==
-      'SELECT * FROM test ORDER BY name DESC, price ASC'
+    @dataset.reverse_order(:name, :price.desc).sql.should == 'SELECT * FROM test ORDER BY name DESC, price ASC'
   end
 
   specify "should handles NULLS ordering correctly when reversing" do
-    @dataset.reverse_order(:name.asc(:nulls=>:first), :price.desc(:nulls=>:last)).sql.should ==
-      'SELECT * FROM test ORDER BY name DESC NULLS LAST, price ASC NULLS FIRST'
+    @dataset.reverse_order(:name.asc(:nulls=>:first), :price.desc(:nulls=>:last)).sql.should == 'SELECT * FROM test ORDER BY name DESC NULLS LAST, price ASC NULLS FIRST'
   end
 
   specify "should reverse a previous ordering if no arguments are given" do
-    @dataset.order(:name).reverse_order.sql.should ==
-      'SELECT * FROM test ORDER BY name DESC'
-    @dataset.order(:clumsy.desc, :fool).reverse_order.sql.should ==
-      'SELECT * FROM test ORDER BY clumsy ASC, fool DESC'
+    @dataset.order(:name).reverse_order.sql.should == 'SELECT * FROM test ORDER BY name DESC'
+    @dataset.order(:clumsy.desc, :fool).reverse_order.sql.should == 'SELECT * FROM test ORDER BY clumsy ASC, fool DESC'
   end
   
   specify "should return an unordered dataset for a dataset with no order" do
-    @dataset.unordered.reverse_order.sql.should == 
-      'SELECT * FROM test'
+    @dataset.unordered.reverse_order.sql.should == 'SELECT * FROM test'
   end
   
   specify "should have #reverse alias" do
-    @dataset.order(:name).reverse.sql.should ==
-      'SELECT * FROM test ORDER BY name DESC'
+    @dataset.order(:name).reverse.sql.should == 'SELECT * FROM test ORDER BY name DESC'
   end
 end
 
@@ -1486,42 +1569,33 @@ describe "Dataset#limit" do
   end
   
   specify "should include a LIMIT clause in the select statement" do
-    @dataset.limit(10).sql.should == 
-      'SELECT * FROM test LIMIT 10'
+    @dataset.limit(10).sql.should == 'SELECT * FROM test LIMIT 10'
   end
   
   specify "should accept ranges" do
-    @dataset.limit(3..7).sql.should ==
-      'SELECT * FROM test LIMIT 5 OFFSET 3'
-      
-    @dataset.limit(3...7).sql.should ==
-      'SELECT * FROM test LIMIT 4 OFFSET 3'
+    @dataset.limit(3..7).sql.should == 'SELECT * FROM test LIMIT 5 OFFSET 3'
+    @dataset.limit(3...7).sql.should == 'SELECT * FROM test LIMIT 4 OFFSET 3'
   end
   
   specify "should include an offset if a second argument is given" do
-    @dataset.limit(6, 10).sql.should ==
-      'SELECT * FROM test LIMIT 6 OFFSET 10'
-    end
+    @dataset.limit(6, 10).sql.should == 'SELECT * FROM test LIMIT 6 OFFSET 10'
+  end
     
   specify "should convert regular strings to integers" do
-    @dataset.limit('6', 'a() - 1').sql.should ==
-      'SELECT * FROM test LIMIT 6 OFFSET 0'
+    @dataset.limit('6', 'a() - 1').sql.should == 'SELECT * FROM test LIMIT 6 OFFSET 0'
   end
   
   specify "should not convert literal strings to integers" do
-    @dataset.limit('6'.lit, 'a() - 1'.lit).sql.should ==
-      'SELECT * FROM test LIMIT 6 OFFSET a() - 1'
+    @dataset.limit('6'.lit, 'a() - 1'.lit).sql.should == 'SELECT * FROM test LIMIT 6 OFFSET a() - 1'
   end
     
   specify "should not convert other objects" do
-    @dataset.limit(6, :a.sql_function - 1).sql.should ==
-      'SELECT * FROM test LIMIT 6 OFFSET (a() - 1)'
+    @dataset.limit(6, :a.sql_function - 1).sql.should == 'SELECT * FROM test LIMIT 6 OFFSET (a() - 1)'
   end
   
   specify "should work with fixed sql datasets" do
     @dataset.opts[:sql] = 'select * from cccc'
-    @dataset.limit(6, 10).sql.should ==
-      'SELECT * FROM (select * from cccc) AS t1 LIMIT 6 OFFSET 10'
+    @dataset.limit(6, 10).sql.should == 'SELECT * FROM (select * from cccc) AS t1 LIMIT 6 OFFSET 10'
   end
   
   specify "should raise an error if an invalid limit or offset is used" do
@@ -1535,15 +1609,20 @@ describe "Dataset#limit" do
 end
 
 describe "Dataset#naked" do
-  before do
-    @d1 = Sequel::Dataset.new(nil, {1 => 2, 3 => 4})
-    @d2 = @d1.clone
-    @d2.row_proc = Proc.new{|r| r}
+  specify "should returned clone dataset without row_proc" do
+    d = Sequel::Dataset.new(nil)
+    d.row_proc = Proc.new{|r| r}
+    d.naked.row_proc.should be_nil
+    d.row_proc.should_not be_nil
   end
-  
+end
+
+describe "Dataset#naked!" do
   specify "should remove any existing row_proc" do
-    naked = @d2.naked
-    naked.row_proc.should be_nil
+    d = Sequel::Dataset.new(nil)
+    d.row_proc = Proc.new{|r| r}
+    d.naked!.row_proc.should be_nil
+    d.row_proc.should be_nil
   end
 end
 
@@ -1571,38 +1650,42 @@ describe "Dataset#qualified_column_name" do
   end
 end
 
-class DummyDataset < Sequel::Dataset
-  VALUES = [
-    {:a => 1, :b => 2},
-    {:a => 3, :b => 4},
-    {:a => 5, :b => 6}
-  ]
-  def fetch_rows(sql, &block)
-    VALUES.each(&block)
-  end
-end
-
 describe "Dataset#map" do
   before do
-    @d = DummyDataset.new(nil).from(:items)
+    @d = Sequel.mock(:fetch=>[{:a => 1, :b => 2}, {:a => 3, :b => 4}, {:a => 5, :b => 6}])[:items]
   end
   
   specify "should provide the usual functionality if no argument is given" do
-    @d.map {|n| n[:a] + n[:b]}.should == [3, 7, 11]
+    @d.map{|n| n[:a] + n[:b]}.should == [3, 7, 11]
   end
   
   specify "should map using #[column name] if column name is given" do
     @d.map(:a).should == [1, 3, 5]
   end
   
+  specify "should support multiple column names if an array of column names is given" do
+    @d.map([:a, :b]).should == [[1, 2], [3, 4], [5, 6]]
+  end
+  
+  specify "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.map(:a).should == [1, 3, 5]
+    @d.map([:a, :b]).should == [[1, 2], [3, 4], [5, 6]]
+  end
+
+  specify "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.map{|n| n[:a] + n[:b]}.should == [6, 14, 22]
+  end
+  
   specify "should return the complete dataset values if nothing is given" do
-    @d.map.to_a.should == DummyDataset::VALUES
+    @d.map.to_a.should == [{:a => 1, :b => 2}, {:a => 3, :b => 4}, {:a => 5, :b => 6}]
   end
 end
 
 describe "Dataset#to_hash" do
   before do
-    @d = DummyDataset.new(nil).from(:items)
+    @d = Sequel.mock(:fetch=>[{:a => 1, :b => 2}, {:a => 3, :b => 4}, {:a => 5, :b => 6}])[:items]
   end
   
   specify "should provide a hash with the first column as key and the second as value" do
@@ -1614,11 +1697,35 @@ describe "Dataset#to_hash" do
     @d.to_hash(:a).should == {1 => {:a => 1, :b => 2}, 3 => {:a => 3, :b => 4}, 5 => {:a => 5, :b => 6}}
     @d.to_hash(:b).should == {2 => {:a => 1, :b => 2}, 4 => {:a => 3, :b => 4}, 6 => {:a => 5, :b => 6}}
   end
+
+  specify "should support using an array of columns as either the key or the value" do
+    @d.to_hash([:a, :b], :b).should == {[1, 2] => 2, [3, 4] => 4, [5, 6] => 6}
+    @d.to_hash(:b, [:a, :b]).should == {2 => [1, 2], 4 => [3, 4], 6 => [5, 6]}
+    @d.to_hash([:b, :a], [:a, :b]).should == {[2, 1] => [1, 2], [4, 3] => [3, 4], [6, 5] => [5, 6]}
+    @d.to_hash([:a, :b]).should == {[1, 2] => {:a => 1, :b => 2}, [3, 4] => {:a => 3, :b => 4}, [5, 6] => {:a => 5, :b => 6}}
+  end
+
+  specify "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.to_hash(:a, :b).should == {1 => 2, 3 => 4, 5 => 6}
+    @d.to_hash(:b, :a).should == {2 => 1, 4 => 3, 6 => 5}
+    @d.to_hash([:a, :b], :b).should == {[1, 2] => 2, [3, 4] => 4, [5, 6] => 6}
+    @d.to_hash(:b, [:a, :b]).should == {2 => [1, 2], 4 => [3, 4], 6 => [5, 6]}
+    @d.to_hash([:b, :a], [:a, :b]).should == {[2, 1] => [1, 2], [4, 3] => [3, 4], [6, 5] => [5, 6]}
+  end
+
+  specify "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.to_hash(:a).should == {2 => {:a => 2, :b => 4}, 6 => {:a => 6, :b => 8}, 10 => {:a => 10, :b => 12}}
+    @d.to_hash(:b).should == {4 => {:a => 2, :b => 4}, 8 => {:a => 6, :b => 8}, 12 => {:a => 10, :b => 12}}
+    @d.to_hash([:a, :b]).should == {[2, 4] => {:a => 2, :b => 4}, [6, 8] => {:a => 6, :b => 8}, [10, 12] => {:a => 10, :b => 12}}
+  end
+  
 end
 
 describe "Dataset#distinct" do
   before do
-    @db = MockDatabase.new
+    @db = Sequel.mock
     @dataset = @db[:test].select(:name)
   end
   
@@ -1645,132 +1752,100 @@ end
 
 describe "Dataset#count" do
   before do
-    @c = Class.new(Sequel::Dataset) do
-      def self.sql
-        @@sql
-      end
-      
-      def fetch_rows(sql)
-        @columns = [sql =~ /SELECT COUNT/i ? :count : :a]
-        @@sql = sql
-        yield({@columns.first=>1})
-      end
-    end
-    @dataset = @c.new(nil).from(:test)
+    @db = Sequel.mock(:fetch=>{:count=>1})
+    @dataset = @db.from(:test).columns(:count)
   end
   
   specify "should format SQL properly" do
     @dataset.count.should == 1
-    @c.sql.should == 'SELECT COUNT(*) AS count FROM test LIMIT 1'
+    @db.sqls.should == ['SELECT COUNT(*) AS count FROM test LIMIT 1']
   end
   
   specify "should include the where clause if it's there" do
     @dataset.filter(:abc.sql_number < 30).count.should == 1
-    @c.sql.should == 'SELECT COUNT(*) AS count FROM test WHERE (abc < 30) LIMIT 1'
+    @db.sqls.should == ['SELECT COUNT(*) AS count FROM test WHERE (abc < 30) LIMIT 1']
   end
   
   specify "should count properly for datasets with fixed sql" do
     @dataset.opts[:sql] = "select abc from xyz"
     @dataset.count.should == 1
-    @c.sql.should == "SELECT COUNT(*) AS count FROM (select abc from xyz) AS t1 LIMIT 1"
+    @db.sqls.should == ["SELECT COUNT(*) AS count FROM (select abc from xyz) AS t1 LIMIT 1"]
   end
 
   specify "should count properly when using UNION, INTERSECT, or EXCEPT" do
     @dataset.union(@dataset).count.should == 1
-    @c.sql.should == "SELECT COUNT(*) AS count FROM (SELECT * FROM test UNION SELECT * FROM test) AS t1 LIMIT 1"
+    @db.sqls.should == ["SELECT COUNT(*) AS count FROM (SELECT * FROM test UNION SELECT * FROM test) AS t1 LIMIT 1"]
     @dataset.intersect(@dataset).count.should == 1
-    @c.sql.should == "SELECT COUNT(*) AS count FROM (SELECT * FROM test INTERSECT SELECT * FROM test) AS t1 LIMIT 1"
+    @db.sqls.should == ["SELECT COUNT(*) AS count FROM (SELECT * FROM test INTERSECT SELECT * FROM test) AS t1 LIMIT 1"]
     @dataset.except(@dataset).count.should == 1
-    @c.sql.should == "SELECT COUNT(*) AS count FROM (SELECT * FROM test EXCEPT SELECT * FROM test) AS t1 LIMIT 1"
+    @db.sqls.should == ["SELECT COUNT(*) AS count FROM (SELECT * FROM test EXCEPT SELECT * FROM test) AS t1 LIMIT 1"]
   end
 
   specify "should return limit if count is greater than it" do
     @dataset.limit(5).count.should == 1
-    @c.sql.should == "SELECT COUNT(*) AS count FROM (SELECT * FROM test LIMIT 5) AS t1 LIMIT 1"
+    @db.sqls.should == ["SELECT COUNT(*) AS count FROM (SELECT * FROM test LIMIT 5) AS t1 LIMIT 1"]
   end
   
   it "should work on a graphed_dataset" do
     @dataset.should_receive(:columns).twice.and_return([:a])
     @dataset.graph(@dataset, [:a], :table_alias=>:test2).count.should == 1
-    @c.sql.should == 'SELECT COUNT(*) AS count FROM test LEFT OUTER JOIN test AS test2 USING (a) LIMIT 1'
+    @db.sqls.should == ['SELECT COUNT(*) AS count FROM test LEFT OUTER JOIN test AS test2 USING (a) LIMIT 1']
   end
 
   specify "should not cache the columns value" do
-    ds = @dataset.from(:blah)
+    ds = @dataset.from(:blah).columns(:a)
     ds.columns.should == [:a]
     ds.count.should == 1
-    @c.sql.should == 'SELECT COUNT(*) AS count FROM blah LIMIT 1'
+    @db.sqls.should == ['SELECT COUNT(*) AS count FROM blah LIMIT 1']
     ds.columns.should == [:a]
   end
 end
 
-
 describe "Dataset#group_and_count" do
   before do
-    @c = Class.new(Sequel::Dataset) do
-      def self.sql
-        @@sql
-      end
-      
-      def fetch_rows(sql)
-        @@sql = sql
-        yield({1 => 1})
-      end
-    end
-    @ds = @c.new(nil).from(:test)
+    @ds = Sequel::Dataset.new(nil).from(:test)
   end
   
   specify "should format SQL properly" do
-    @ds.group_and_count(:name).sql.should == 
-      "SELECT name, count(*) AS count FROM test GROUP BY name"
+    @ds.group_and_count(:name).sql.should == "SELECT name, count(*) AS count FROM test GROUP BY name"
   end
 
   specify "should accept multiple columns for grouping" do
-    @ds.group_and_count(:a, :b).sql.should == 
-      "SELECT a, b, count(*) AS count FROM test GROUP BY a, b"
+    @ds.group_and_count(:a, :b).sql.should == "SELECT a, b, count(*) AS count FROM test GROUP BY a, b"
   end
 
   specify "should format column aliases in the select clause but not in the group clause" do
-    @ds.group_and_count(:name___n).sql.should ==
-      "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
-    @ds.group_and_count(:name__n).sql.should ==
-      "SELECT name.n, count(*) AS count FROM test GROUP BY name.n"
+    @ds.group_and_count(:name___n).sql.should == "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
+    @ds.group_and_count(:name__n).sql.should == "SELECT name.n, count(*) AS count FROM test GROUP BY name.n"
   end
 
   specify "should handle identifiers" do
-    @ds.group_and_count(:name___n.identifier).sql.should ==
-      "SELECT name___n, count(*) AS count FROM test GROUP BY name___n"
+    @ds.group_and_count(:name___n.identifier).sql.should == "SELECT name___n, count(*) AS count FROM test GROUP BY name___n"
   end
 
   specify "should handle literal strings" do
-    @ds.group_and_count("name".lit).sql.should ==
-      "SELECT name, count(*) AS count FROM test GROUP BY name"
+    @ds.group_and_count("name".lit).sql.should == "SELECT name, count(*) AS count FROM test GROUP BY name"
   end
 
   specify "should handle aliased expressions" do
-    @ds.group_and_count(:name.as(:n)).sql.should ==
-      "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
-    @ds.group_and_count(:name.identifier.as(:n)).sql.should ==
-      "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
+    @ds.group_and_count(:name.as(:n)).sql.should == "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
+    @ds.group_and_count(:name.identifier.as(:n)).sql.should == "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
+  end
+
+  specify "should take a virtual row block" do
+    @ds.group_and_count{(type_id > 1).as(t)}.sql.should == "SELECT (type_id > 1) AS t, count(*) AS count FROM test GROUP BY (type_id > 1)"
+    @ds.group_and_count{[(type_id > 1).as(t), type_id < 2]}.sql.should == "SELECT (type_id > 1) AS t, (type_id < 2), count(*) AS count FROM test GROUP BY (type_id > 1), (type_id < 2)"
+    @ds.group_and_count(:foo){type_id > 1}.sql.should == "SELECT foo, (type_id > 1), count(*) AS count FROM test GROUP BY foo, (type_id > 1)"
   end
 end
 
 describe "Dataset#empty?" do
   specify "should return true if records exist in the dataset" do
-    @c = Class.new(Sequel::Dataset) do
-      def self.sql
-        @@sql
-      end
-      
-      def fetch_rows(sql)
-        @@sql = sql
-        yield({1 => 1}) unless sql =~ /WHERE 'f'/
-      end
-    end
-    @c.new(nil).from(:test).should_not be_empty
-    @c.sql.should == 'SELECT 1 FROM test LIMIT 1'
-    @c.new(nil).from(:test).filter(false).should be_empty
-    @c.sql.should == "SELECT 1 FROM test WHERE 'f' LIMIT 1"
+    db = Sequel.mock(:fetch=>proc{|sql| {1=>1} unless sql =~ /WHERE 'f'/})
+    db.from(:test).should_not be_empty
+    db.sqls.should == ['SELECT 1 AS one FROM test LIMIT 1']
+    db.from(:test).filter(false).should be_empty
+    db.sqls.should == ["SELECT 1 AS one FROM test WHERE 'f' LIMIT 1"]
   end
 end
 
@@ -1817,9 +1892,9 @@ describe "Dataset#first_source_table" do
   end
   
   specify "should be the unaliased part if aliased" do
-    @ds.from(:t___a).first_source_table.should == :t.identifier
-    @ds.from(:s__t___a).first_source_table.should == :t.qualify(:s)
-    @ds.from(:t.as(:a)).first_source_table.should == :t
+    @ds.literal(@ds.from(:t___a).first_source_table).should == "t"
+    @ds.literal(@ds.from(:s__t___a).first_source_table).should == "s.t"
+    @ds.literal(@ds.from(:t.as(:a)).first_source_table).should == "t"
   end
   
   specify "should raise exception if table doesn't have a source" do
@@ -1849,25 +1924,31 @@ describe "Dataset#from_self" do
       'SELECT * FROM (SELECT name FROM test LIMIT 1) AS some_name INNER JOIN posts ON (posts.alias = some_name.name)'
   end
   
-  specify "should not options such as server" do
+  specify "should not remove non-SQL options such as :server" do
     @ds.server(:blah).from_self(:alias=>:some_name).opts[:server].should == :blah
   end
 
+  specify "should hoist WITH clauses in current dataset if dataset doesn't support WITH in subselect" do
+    ds = Sequel::Dataset.new(nil)
+    ds.meta_def(:supports_cte?){true}
+    ds.meta_def(:supports_cte_in_subselect?){false}
+    ds.from(:a).with(:a, ds.from(:b)).from_self.sql.should == '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.should == 'WITH a AS (SELECT * FROM b), c AS (SELECT * FROM d) SELECT * FROM (SELECT * FROM a, c) AS t1'
+  end
 end
 
 describe "Dataset#join_table" do
   before do
-    @d = MockDataset.new(nil).from(:items)
+    @d = Sequel::Dataset.new(nil).from(:items)
     @d.quote_identifiers = true
   end
   
   specify "should format the JOIN clause properly" do
-    @d.join_table(:left_outer, :categories, :category_id => :id).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.join_table(:left_outer, :categories, :category_id => :id).sql.should == 'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
   end
   
   specify "should handle multiple conditions on the same join table column" do
-    @d.join_table(:left_outer, :categories, [[:category_id, :id], [:category_id, 0..100]]).sql.should ==
+    @d.join_table(:left_outer, :categories, [[:category_id, :id], [:category_id, 0..100]]).sql.should == 
       'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON (("categories"."category_id" = "items"."id") AND ("categories"."category_id" >= 0) AND ("categories"."category_id" <= 100))'
   end
   
@@ -1877,45 +1958,30 @@ describe "Dataset#join_table" do
   end
   
   specify "should include ORDER BY clause if applicable" do
-    @d.order(:stamp).join_table(:full_outer, :categories, :category_id => :id).sql.should ==
-      'SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id") ORDER BY "stamp"'
+    @d.order(:stamp).join_table(:full_outer, :categories, :category_id => :id).sql.should == 'SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id") ORDER BY "stamp"'
   end
   
   specify "should support multiple joins" do
-    @d.join_table(:inner, :b, :items_id=>:id).join_table(:left_outer, :c, :b_id => :b__id).sql.should ==
-      'SELECT * FROM "items" INNER JOIN "b" ON ("b"."items_id" = "items"."id") LEFT OUTER JOIN "c" ON ("c"."b_id" = "b"."id")'
+    @d.join_table(:inner, :b, :items_id=>:id).join_table(:left_outer, :c, :b_id => :b__id).sql.should == 'SELECT * FROM "items" INNER JOIN "b" ON ("b"."items_id" = "items"."id") LEFT OUTER JOIN "c" ON ("c"."b_id" = "b"."id")'
   end
   
   specify "should support arbitrary join types" do
-    @d.join_table(:magic, :categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" MAGIC JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.join_table(:magic, :categories, :category_id=>:id).sql.should == 'SELECT * FROM "items" MAGIC JOIN "categories" ON ("categories"."category_id" = "items"."id")'
   end
 
   specify "should support many join methods" do
-    @d.left_outer_join(:categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-    @d.right_outer_join(:categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" RIGHT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-    @d.full_outer_join(:categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-    @d.inner_join(:categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-    @d.left_join(:categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" LEFT JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-    @d.right_join(:categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" RIGHT JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-    @d.full_join(:categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" FULL JOIN "categories" ON ("categories"."category_id" = "items"."id")'
-    @d.natural_join(:categories).sql.should ==
-      'SELECT * FROM "items" NATURAL JOIN "categories"'
-    @d.natural_left_join(:categories).sql.should ==
-      'SELECT * FROM "items" NATURAL LEFT JOIN "categories"'
-    @d.natural_right_join(:categories).sql.should ==
-      'SELECT * FROM "items" NATURAL RIGHT JOIN "categories"'
-    @d.natural_full_join(:categories).sql.should ==
-      'SELECT * FROM "items" NATURAL FULL JOIN "categories"'
-    @d.cross_join(:categories).sql.should ==
-      'SELECT * FROM "items" CROSS JOIN "categories"'
+    @d.left_outer_join(:categories, :category_id=>:id).sql.should == 'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.right_outer_join(:categories, :category_id=>:id).sql.should == 'SELECT * FROM "items" RIGHT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.full_outer_join(:categories, :category_id=>:id).sql.should == 'SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.inner_join(:categories, :category_id=>:id).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.left_join(:categories, :category_id=>:id).sql.should == 'SELECT * FROM "items" LEFT JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.right_join(:categories, :category_id=>:id).sql.should == 'SELECT * FROM "items" RIGHT JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.full_join(:categories, :category_id=>:id).sql.should == 'SELECT * FROM "items" FULL JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.natural_join(:categories).sql.should == 'SELECT * FROM "items" NATURAL JOIN "categories"'
+    @d.natural_left_join(:categories).sql.should == 'SELECT * FROM "items" NATURAL LEFT JOIN "categories"'
+    @d.natural_right_join(:categories).sql.should == 'SELECT * FROM "items" NATURAL RIGHT JOIN "categories"'
+    @d.natural_full_join(:categories).sql.should == 'SELECT * FROM "items" NATURAL FULL JOIN "categories"'
+    @d.cross_join(:categories).sql.should == 'SELECT * FROM "items" CROSS JOIN "categories"'
   end
   
   specify "should raise an error if additional arguments are provided to join methods that don't take conditions" do
@@ -1935,95 +2001,68 @@ describe "Dataset#join_table" do
   end
 
   specify "should default to a plain join if nil is used for the type" do
-    @d.join_table(nil, :categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items"  JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.join_table(nil, :categories, :category_id=>:id).sql.should == 'SELECT * FROM "items"  JOIN "categories" ON ("categories"."category_id" = "items"."id")'
   end
 
   specify "should use an inner join for Dataset#join" do
-    @d.join(:categories, :category_id=>:id).sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+    @d.join(:categories, :category_id=>:id).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
   end
   
   specify "should support aliased tables using the deprecated argument" do
-    @d.from('stats').join('players', {:id => :player_id}, 'p').sql.should ==
-      'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
+    @d.from('stats').join('players', {:id => :player_id}, 'p').sql.should == 'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
   end
 
   specify "should support aliased tables using the :table_alias option" do
-    @d.from('stats').join('players', {:id => :player_id}, :table_alias=>:p).sql.should ==
-      'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
+    @d.from('stats').join('players', {:id => :player_id}, :table_alias=>:p).sql.should == 'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
   end
   
   specify "should support aliased tables using an implicit alias" do
-    @d.from('stats').join(:players.as(:p), {:id => :player_id}).sql.should ==
-      'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
+    @d.from('stats').join(:players.as(:p), {:id => :player_id}).sql.should == 'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
   end
   
   specify "should support using an alias for the FROM when doing the first join with unqualified condition columns" do
-    ds = MockDataset.new(nil).from(:foo => :f)
-    ds.quote_identifiers = true
-    ds.join_table(:inner, :bar, :id => :bar_id).sql.should ==
-      'SELECT * FROM "foo" AS "f" INNER JOIN "bar" ON ("bar"."id" = "f"."bar_id")'
+    @d.from(:foo=>:f).join_table(:inner, :bar, :id => :bar_id).sql.should == 'SELECT * FROM "foo" AS "f" INNER JOIN "bar" ON ("bar"."id" = "f"."bar_id")'
   end
   
   specify "should support implicit schemas in from table symbols" do
-    @d.from(:s__t).join(:u__v, {:id => :player_id}).sql.should ==
-      'SELECT * FROM "s"."t" INNER JOIN "u"."v" ON ("u"."v"."id" = "s"."t"."player_id")'
+    @d.from(:s__t).join(:u__v, {:id => :player_id}).sql.should == 'SELECT * FROM "s"."t" INNER JOIN "u"."v" ON ("u"."v"."id" = "s"."t"."player_id")'
   end
 
   specify "should support implicit aliases in from table symbols" do
-    @d.from(:t___z).join(:v___y, {:id => :player_id}).sql.should ==
-      'SELECT * FROM "t" AS "z" INNER JOIN "v" AS "y" ON ("y"."id" = "z"."player_id")'
-    @d.from(:s__t___z).join(:u__v___y, {:id => :player_id}).sql.should ==
-      'SELECT * FROM "s"."t" AS "z" INNER JOIN "u"."v" AS "y" ON ("y"."id" = "z"."player_id")'
+    @d.from(:t___z).join(:v___y, {:id => :player_id}).sql.should == 'SELECT * FROM "t" AS "z" INNER JOIN "v" AS "y" ON ("y"."id" = "z"."player_id")'
+    @d.from(:s__t___z).join(:u__v___y, {:id => :player_id}).sql.should == 'SELECT * FROM "s"."t" AS "z" INNER JOIN "u"."v" AS "y" ON ("y"."id" = "z"."player_id")'
   end
   
   specify "should support AliasedExpressions" do
-    @d.from(:s.as(:t)).join(:u.as(:v), {:id => :player_id}).sql.should ==
-      'SELECT * FROM "s" AS "t" INNER JOIN "u" AS "v" ON ("v"."id" = "t"."player_id")'
+    @d.from(:s.as(:t)).join(:u.as(:v), {:id => :player_id}).sql.should == 'SELECT * FROM "s" AS "t" INNER JOIN "u" AS "v" ON ("v"."id" = "t"."player_id")'
   end
 
   specify "should support the :implicit_qualifier option" do
-    @d.from('stats').join('players', {:id => :player_id}, :implicit_qualifier=>:p).sql.should ==
-      'SELECT * FROM "stats" INNER JOIN "players" ON ("players"."id" = "p"."player_id")'
+    @d.from('stats').join('players', {:id => :player_id}, :implicit_qualifier=>:p).sql.should == 'SELECT * FROM "stats" INNER JOIN "players" ON ("players"."id" = "p"."player_id")'
   end
   
   specify "should allow for arbitrary conditions in the JOIN clause" do
-    @d.join_table(:left_outer, :categories, :status => 0).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."status" = 0)'
-    @d.join_table(:left_outer, :categories, :categorizable_type => "Post").sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."categorizable_type" = \'Post\')'
-    @d.join_table(:left_outer, :categories, :timestamp => "CURRENT_TIMESTAMP".lit).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."timestamp" = CURRENT_TIMESTAMP)'
-    @d.join_table(:left_outer, :categories, :status => [1, 2, 3]).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."status" IN (1, 2, 3))'
+    @d.join_table(:left_outer, :categories, :status => 0).sql.should == 'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."status" = 0)'
+    @d.join_table(:left_outer, :categories, :categorizable_type => "Post").sql.should == 'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."categorizable_type" = \'Post\')'
+    @d.join_table(:left_outer, :categories, :timestamp => "CURRENT_TIMESTAMP".lit).sql.should == 'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."timestamp" = CURRENT_TIMESTAMP)'
+    @d.join_table(:left_outer, :categories, :status => [1, 2, 3]).sql.should == 'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."status" IN (1, 2, 3))'
   end
   
   specify "should raise error for a table without a source" do
-    proc {Sequel::Dataset.new(nil).join('players', :id => :player_id)}. \
-      should raise_error(Sequel::Error)
+    proc {Sequel::Dataset.new(nil).join('players', :id => :player_id)}.should raise_error(Sequel::Error)
   end
 
   specify "should support joining datasets" do
     ds = Sequel::Dataset.new(nil).from(:categories)
-    
-    @d.join_table(:left_outer, ds, :item_id => :id).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) AS "t1" ON ("t1"."item_id" = "items"."id")'
-      
+    @d.join_table(:left_outer, ds, :item_id => :id).sql.should == 'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) AS "t1" ON ("t1"."item_id" = "items"."id")'
     ds.filter!(:active => true)
-
-    @d.join_table(:left_outer, ds, :item_id => :id).sql.should ==
-      '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.should ==
-      '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")'
+    @d.join_table(:left_outer, ds, :item_id => :id).sql.should == '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.should == '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
   
   specify "should support joining datasets and aliasing the join" do
     ds = Sequel::Dataset.new(nil).from(:categories)
-    
-    @d.join_table(:left_outer, ds, {:ds__item_id => :id}, :ds).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) AS "ds" ON ("ds"."item_id" = "items"."id")'      
+    @d.join_table(:left_outer, ds, {:ds__item_id => :id}, :ds).sql.should == 'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) AS "ds" ON ("ds"."item_id" = "items"."id")'      
   end
   
   specify "should support joining multiple datasets" do
@@ -2040,40 +2079,30 @@ describe "Dataset#join_table" do
   specify "should support joining objects that respond to :table_name" do
     ds = Object.new
     def ds.table_name; :categories end
-    
-    @d.join(ds, :item_id => :id).sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."item_id" = "items"."id")'
+    @d.join(ds, :item_id => :id).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."item_id" = "items"."id")'
   end
   
-  specify "should support using a SQL String as the join condition" do
-    @d.join(:categories, %{c.item_id = items.id}, :c).sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" AS "c" ON (c.item_id = items.id)'
+  specify "should support using an SQL String as the join condition" do
+    @d.join(:categories, "c.item_id = items.id", :c).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" AS "c" ON (c.item_id = items.id)'
   end
   
   specify "should support using a boolean column as the join condition" do
-    @d.join(:categories, :active).sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" ON "active"'
+    @d.join(:categories, :active).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON "active"'
   end
 
   specify "should support using an expression as the join condition" do
-    @d.join(:categories, :number.sql_number > 10).sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" ON ("number" > 10)'
+    @d.join(:categories, :number.sql_number > 10).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON ("number" > 10)'
   end
 
-  specify "should support natural and cross joins using nil" do
-    @d.join_table(:natural, :categories).sql.should ==
-      'SELECT * FROM "items" NATURAL JOIN "categories"'
-    @d.join_table(:cross, :categories, nil).sql.should ==
-      'SELECT * FROM "items" CROSS JOIN "categories"'
-    @d.join_table(:natural, :categories, nil, :c).sql.should ==
-      'SELECT * FROM "items" NATURAL JOIN "categories" AS "c"'
+  specify "should support natural and cross joins" do
+    @d.join_table(:natural, :categories).sql.should == 'SELECT * FROM "items" NATURAL JOIN "categories"'
+    @d.join_table(:cross, :categories, nil).sql.should == 'SELECT * FROM "items" CROSS JOIN "categories"'
+    @d.join_table(:natural, :categories, nil, :c).sql.should == 'SELECT * FROM "items" NATURAL JOIN "categories" AS "c"'
   end
 
   specify "should support joins with a USING clause if an array of symbols is used" do
-    @d.join(:categories, [:id]).sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" USING ("id")'
-    @d.join(:categories, [:id1, :id2]).sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" USING ("id1", "id2")'
+    @d.join(:categories, [:id]).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" USING ("id")'
+    @d.join(:categories, [:id1, :id2]).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" USING ("id1", "id2")'
   end
 
   specify "should emulate JOIN USING (poorly) if the dataset doesn't support it" do
@@ -2081,6 +2110,12 @@ describe "Dataset#join_table" do
     @d.join(:categories, [:id]).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."id" = "items"."id")'
   end
 
+  specify "should hoist WITH clauses from subqueries if the dataset doesn't support CTEs in subselects" do
+    @d.meta_def(:supports_cte?){true}
+    @d.meta_def(:supports_cte_in_subselect?){false}
+    @d.join(Sequel::Dataset.new(nil).from(:categories).with(:a, Sequel::Dataset.new(nil).from(:b)), [:id]).sql.should == 'WITH "a" AS (SELECT * FROM b) SELECT * FROM "items" INNER JOIN (SELECT * FROM categories) AS "t1" USING ("id")'
+  end
+
   specify "should raise an error if using an array of symbols with a block" do
     proc{@d.join(:categories, [:id]){|j,lj,js|}}.should raise_error(Sequel::Error)
   end
@@ -2135,27 +2170,21 @@ describe "Dataset#join_table" do
   end
 
   specify "should use the block result as the only condition if no condition is given" do
-    @d.join(:categories){|j,lj,js| {:b.qualify(j)=>:c.qualify(lj)}}.sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."b" = "items"."c")'
-    @d.join(:categories){|j,lj,js| :b.qualify(j) > :c.qualify(lj)}.sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."b" > "items"."c")'
+    @d.join(:categories){|j,lj,js| {:b.qualify(j)=>:c.qualify(lj)}}.sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."b" = "items"."c")'
+    @d.join(:categories){|j,lj,js| :b.qualify(j) > :c.qualify(lj)}.sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."b" > "items"."c")'
   end
 
   specify "should combine the block conditions and argument conditions if both given" do
-    @d.join(:categories, :a=>:d){|j,lj,js| {:b.qualify(j)=>:c.qualify(lj)}}.sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" ON (("categories"."a" = "items"."d") AND ("categories"."b" = "items"."c"))'
-    @d.join(:categories, :a=>:d){|j,lj,js| :b.qualify(j) > :c.qualify(lj)}.sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" ON (("categories"."a" = "items"."d") AND ("categories"."b" > "items"."c"))'
+    @d.join(:categories, :a=>:d){|j,lj,js| {:b.qualify(j)=>:c.qualify(lj)}}.sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON (("categories"."a" = "items"."d") AND ("categories"."b" = "items"."c"))'
+    @d.join(:categories, :a=>:d){|j,lj,js| :b.qualify(j) > :c.qualify(lj)}.sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON (("categories"."a" = "items"."d") AND ("categories"."b" > "items"."c"))'
   end
 
   specify "should prefer explicit aliases over implicit" do
-    @d.from(:items___i).join(:categories___c, {:category_id => :id}, {:table_alias=>:c2, :implicit_qualifier=>:i2}).sql.should ==
-      'SELECT * FROM "items" AS "i" INNER JOIN "categories" AS "c2" ON ("c2"."category_id" = "i2"."id")'
+    @d.from(:items___i).join(:categories___c, {:category_id => :id}, {:table_alias=>:c2, :implicit_qualifier=>:i2}).sql.should == 'SELECT * FROM "items" AS "i" INNER JOIN "categories" AS "c2" ON ("c2"."category_id" = "i2"."id")'
     @d.from(:items.as(:i)).join(:categories.as(:c), {:category_id => :id}, {:table_alias=>:c2, :implicit_qualifier=>:i2}).sql.should ==
       'SELECT * FROM "items" AS "i" INNER JOIN "categories" AS "c2" ON ("c2"."category_id" = "i2"."id")'
   end
   
-  
   specify "should not allow insert, update, delete, or truncate" do
     proc{@d.join(:categories, :a=>:d).insert_sql}.should raise_error(Sequel::InvalidOperation)
     proc{@d.join(:categories, :a=>:d).update_sql(:a=>1)}.should raise_error(Sequel::InvalidOperation)
@@ -2170,81 +2199,52 @@ describe "Dataset#join_table" do
 end
 
 describe "Dataset#[]=" do
-  before do
-    c = Class.new(Sequel::Dataset) do
-      def last_sql
-        @@last_sql
-      end
-      
-      def update(*args)
-        @@last_sql = update_sql(*args)
-      end
-    end
-    
-    @d = c.new(nil).from(:items)
-  end
-  
   specify "should perform an update on the specified filter" do
-    @d[:a => 1] = {:x => 3}
-    @d.last_sql.should == 'UPDATE items SET x = 3 WHERE (a = 1)'
+    db = Sequel.mock
+    ds = db[:items]
+    ds[:a => 1] = {:x => 3}
+    db.sqls.should == ['UPDATE items SET x = 3 WHERE (a = 1)']
   end
 end
 
 describe "Dataset#set" do
-  before do
-    c = Class.new(Sequel::Dataset) do
-      def last_sql
-        @@last_sql
-      end
-      
-      def update(*args, &block)
-        @@last_sql = update_sql(*args, &block)
-      end
-    end
-    
-    @d = c.new(nil).from(:items)
-  end
-  
   specify "should act as alias to #update" do
-    @d.set({:x => 3})
-    @d.last_sql.should == 'UPDATE items SET x = 3'
+    db = Sequel.mock
+    ds = db[:items]
+    ds.set({:x => 3})
+    db.sqls.should == ['UPDATE items SET x = 3']
   end
 end
 
-
 describe "Dataset#insert_multiple" do
   before do
-    c = Class.new(Sequel::Dataset) do
-      attr_reader :inserts
-      def insert(arg)
-        @inserts ||= []
-        @inserts << arg
-      end
-    end
-    
-    @d = c.new(nil)
+    @db = Sequel.mock(:autoid=>2)
+    @ds = @db[:items]
   end
   
   specify "should insert all items in the supplied array" do
-    @d.insert_multiple [:aa, 5, 3, {1 => 2}]
-    @d.inserts.should == [:aa, 5, 3, {1 => 2}]
+    @ds.insert_multiple(['aa', 5, 3, {:a => 2}])
+    @db.sqls.should == ["INSERT INTO items VALUES ('aa')",
+      "INSERT INTO items VALUES (5)",
+      "INSERT INTO items VALUES (3)",
+      "INSERT INTO items (a) VALUES (2)"]
   end
   
   specify "should pass array items through the supplied block if given" do
-    a = ["inevitable", "hello", "the ticking clock"]
-    @d.insert_multiple(a) {|i| i.gsub('l', 'r')}
-    @d.inserts.should == ["inevitabre", "herro", "the ticking crock"]
+    @ds.insert_multiple(["inevitable", "hello", "the ticking clock"]){|i| i.gsub('l', 'r')}
+    @db.sqls.should == ["INSERT INTO items VALUES ('inevitabre')",
+      "INSERT INTO items VALUES ('herro')",
+      "INSERT INTO items VALUES ('the ticking crock')"]
+  end
+
+  specify "should return array of inserted ids" do
+    @ds.insert_multiple(['aa', 5, 3, {:a => 2}]).should == [2, 3, 4, 5]
   end
 end
 
 describe "Dataset aggregate methods" do
   before do
-    c = Class.new(Sequel::Dataset) do
-      def fetch_rows(sql)
-        yield({1 => sql})
-      end
-    end
-    @d = c.new(nil).from(:test)
+    @d = Sequel.mock(:fetch=>proc{|s| {1=>s}})[:test]
   end
   
   specify "should include min" do
@@ -2278,116 +2278,88 @@ end
 
 describe "Dataset#range" do
   before do
-    c = Class.new(Sequel::Dataset) do
-      class_variable_set(:@@sql, nil)
-      
-      def last_sql; self.class.send(:class_variable_get, :@@sql); end
-      
-      def fetch_rows(sql)
-        self.class.send(:class_variable_set, :@@sql, sql)
-        yield(:v1 => 1, :v2 => 10)
-      end
-    end
-    @d = c.new(nil).from(:test)
+    @db = Sequel.mock(:fetch=>{:v1 => 1, :v2 => 10})
+    @ds = @db[:test]
   end
   
   specify "should generate a correct SQL statement" do
-    @d.range(:stamp)
-    @d.last_sql.should == "SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test LIMIT 1"
+    @ds.range(:stamp)
+    @db.sqls.should == ["SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test LIMIT 1"]
 
-    @d.filter(:price.sql_number > 100).range(:stamp)
-    @d.last_sql.should == "SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test WHERE (price > 100) LIMIT 1"
+    @ds.filter(:price.sql_number > 100).range(:stamp)
+    @db.sqls.should == ["SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test WHERE (price > 100) LIMIT 1"]
   end
   
   specify "should return a range object" do
-    @d.range(:tryme).should == (1..10)
+    @ds.range(:tryme).should == (1..10)
   end
   
   specify "should use a subselect for the same conditions as count" do
-    @d.order(:stamp).limit(5).range(:stamp).should == (1..10)
-    @d.last_sql.should == 'SELECT min(stamp) AS v1, max(stamp) AS v2 FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1'
+    @ds.order(:stamp).limit(5).range(:stamp).should == (1..10)
+    @db.sqls.should == ['SELECT min(stamp) AS v1, max(stamp) AS v2 FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1']
   end
 end
 
 describe "Dataset#interval" do
   before do
-    c = Class.new(Sequel::Dataset) do
-      class_variable_set(:@@sql, nil)
-      
-      def last_sql; self.class.send(:class_variable_get, :@@sql); end
-      
-      def fetch_rows(sql)
-        self.class.send(:class_variable_set, :@@sql, sql)
-        yield(:v => 1234)
-      end
-    end
-    @d = c.new(nil).from(:test)
+    @db = Sequel.mock(:fetch=>{:v => 1234})
+    @ds = @db[:test]
   end
   
-  specify "should generate a correct SQL statement" do
-    @d.interval(:stamp)
-    @d.last_sql.should == "SELECT (max(stamp) - min(stamp)) FROM test LIMIT 1"
+  specify "should generate the correct SQL statement" do
+    @ds.interval(:stamp)
+    @db.sqls.should == ["SELECT (max(stamp) - min(stamp)) FROM test LIMIT 1"]
 
-    @d.filter(:price.sql_number > 100).interval(:stamp)
-    @d.last_sql.should == "SELECT (max(stamp) - min(stamp)) FROM test WHERE (price > 100) LIMIT 1"
-  end
-  
-  specify "should return an integer" do
-    @d.interval(:tryme).should == 1234
+    @ds.filter(:price.sql_number > 100).interval(:stamp)
+    @db.sqls.should == ["SELECT (max(stamp) - min(stamp)) FROM test WHERE (price > 100) LIMIT 1"]
   end
   
   specify "should use a subselect for the same conditions as count" do
-    @d.order(:stamp).limit(5).interval(:stamp).should == 1234
-    @d.last_sql.should == 'SELECT (max(stamp) - min(stamp)) FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1'
+    @ds.order(:stamp).limit(5).interval(:stamp).should == 1234
+    @db.sqls.should == ['SELECT (max(stamp) - min(stamp)) FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1']
   end
 end
 
 describe "Dataset #first and #last" do
   before do
-    @c = Class.new(Sequel::Dataset) do
-      def each(&block)
-        s = select_sql
-        x = [:a,1,:b,2,s]
-        i = /LIMIT (\d+)/.match(s)[1].to_i.times{yield x}
-      end
-    end
-    @d = @c.new(nil).from(:test)
+    @db = Sequel.mock(:fetch=>proc{|s| {:s=>s}})
+    @d = @db[:test]
   end
   
   specify "should return a single record if no argument is given" do
-    @d.order(:a).first.should == [:a,1,:b,2, 'SELECT * FROM test ORDER BY a LIMIT 1']
-    @d.order(:a).last.should == [:a,1,:b,2, 'SELECT * FROM test ORDER BY a DESC LIMIT 1']
+    @d.order(:a).first.should == {:s=>'SELECT * FROM test ORDER BY a LIMIT 1'}
+    @d.order(:a).last.should == {:s=>'SELECT * FROM test ORDER BY a DESC LIMIT 1'}
   end
 
   specify "should return the first/last matching record if argument is not an Integer" do
-    @d.order(:a).first(:z => 26).should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z = 26) ORDER BY a LIMIT 1']
-    @d.order(:a).first('z = ?', 15).should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z = 15) ORDER BY a LIMIT 1']
-    @d.order(:a).last(:z => 26).should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z = 26) ORDER BY a DESC LIMIT 1']
-    @d.order(:a).last('z = ?', 15).should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z = 15) ORDER BY a DESC LIMIT 1']
+    @d.order(:a).first(:z => 26).should == {:s=>'SELECT * FROM test WHERE (z = 26) ORDER BY a LIMIT 1'}
+    @d.order(:a).first('z = ?', 15).should == {:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a LIMIT 1'}
+    @d.order(:a).last(:z => 26).should == {:s=>'SELECT * FROM test WHERE (z = 26) ORDER BY a DESC LIMIT 1'}
+    @d.order(:a).last('z = ?', 15).should == {:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a DESC LIMIT 1'}
   end
   
   specify "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).should == [[:a,1,:b,2, "SELECT * FROM test ORDER BY a LIMIT #{i}"]] * i
+    r = @d.order(:a).first(i).should == [{:s=>"SELECT * FROM test ORDER BY a LIMIT #{i}"}]
     i = rand(10) + 10
-    r = @d.order(:a).last(i).should == [[:a,1,:b,2, "SELECT * FROM test ORDER BY a DESC LIMIT #{i}"]] * i
+    r = @d.order(:a).last(i).should == [{:s=>"SELECT * FROM test ORDER BY a DESC LIMIT #{i}"}]
   end
   
   specify "should return the first matching record if a block is given without an argument" do
-    @d.first{:z.sql_number > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z > 26) LIMIT 1']
-    @d.order(:name).last{:z.sql_number > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z > 26) ORDER BY name DESC LIMIT 1']
+    @d.first{:z.sql_number > 26}.should == {:s=>'SELECT * FROM test WHERE (z > 26) LIMIT 1'}
+    @d.order(:name).last{:z.sql_number > 26}.should == {:s=>'SELECT * FROM test WHERE (z > 26) ORDER BY name DESC LIMIT 1'}
   end
   
   specify "should combine block and standard argument filters if argument is not an Integer" do
-    @d.first(:y=>25){:z.sql_number > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE ((z > 26) AND (y = 25)) LIMIT 1']
-    @d.order(:name).last('y = ?', 16){:z.sql_number > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE ((z > 26) AND (y = 16)) ORDER BY name DESC LIMIT 1']
+    @d.first(:y=>25){:z.sql_number > 26}.should == {:s=>'SELECT * FROM test WHERE ((z > 26) AND (y = 25)) LIMIT 1'}
+    @d.order(:name).last('y = ?', 16){:z.sql_number > 26}.should == {:s=>'SELECT * FROM test WHERE ((z > 26) AND (y = 16)) ORDER BY name DESC LIMIT 1'}
   end
   
   specify "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.sql_number > 26}.should == [[:a,1,:b,2, "SELECT * FROM test WHERE (z > 26) ORDER BY a LIMIT #{i}"]] * i
+    r = @d.order(:a).first(i){:z.sql_number > 26}.should == [{:s=>"SELECT * FROM test WHERE (z > 26) ORDER BY a LIMIT #{i}"}]
     i = rand(10) + 10
-    r = @d.order(:a).last(i){:z.sql_number > 26}.should == [[:a,1,:b,2, "SELECT * FROM test WHERE (z > 26) ORDER BY a DESC LIMIT #{i}"]] * i
+    r = @d.order(:a).last(i){:z.sql_number > 26}.should == [{:s=>"SELECT * FROM test WHERE (z > 26) ORDER BY a DESC LIMIT #{i}"}]
   end
   
   specify "#last should raise if no order is given" do
@@ -2398,10 +2370,10 @@ describe "Dataset #first and #last" do
   end
   
   specify "#last should invert the order" do
-    @d.order(:a).last.pop.should == 'SELECT * FROM test ORDER BY a DESC LIMIT 1'
-    @d.order(:b.desc).last.pop.should == 'SELECT * FROM test ORDER BY b ASC LIMIT 1'
-    @d.order(:c, :d).last.pop.should == 'SELECT * FROM test ORDER BY c DESC, d DESC LIMIT 1'
-    @d.order(:e.desc, :f).last.pop.should == 'SELECT * FROM test ORDER BY e ASC, f DESC LIMIT 1'
+    @d.order(:a).last.should == {:s=>'SELECT * FROM test ORDER BY a DESC LIMIT 1'}
+    @d.order(:b.desc).last.should == {:s=>'SELECT * FROM test ORDER BY b ASC LIMIT 1'}
+    @d.order(:c, :d).last.should == {:s=>'SELECT * FROM test ORDER BY c DESC, d DESC LIMIT 1'}
+    @d.order(:e.desc, :f).last.should == {:s=>'SELECT * FROM test ORDER BY e ASC, f DESC LIMIT 1'}
   end
 end
 
@@ -2412,55 +2384,37 @@ describe "Dataset compound operations" do
   end
   
   specify "should support UNION and UNION ALL" do
-    @a.union(@b).sql.should == \
-      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2)) AS t1"
-    @b.union(@a, true).sql.should == \
-      "SELECT * FROM (SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1"
-    @b.union(@a, :all=>true).sql.should == \
-      "SELECT * FROM (SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+    @a.union(@b).sql.should == "SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2)) AS t1"
+    @b.union(@a, true).sql.should == "SELECT * FROM (SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+    @b.union(@a, :all=>true).sql.should == "SELECT * FROM (SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1"
   end
 
   specify "should support INTERSECT and INTERSECT ALL" do
-    @a.intersect(@b).sql.should == \
-      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT SELECT * FROM b WHERE (z = 2)) AS t1"
-    @b.intersect(@a, true).sql.should == \
-      "SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
-    @b.intersect(@a, :all=>true).sql.should == \
-      "SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+    @a.intersect(@b).sql.should == "SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT SELECT * FROM b WHERE (z = 2)) AS t1"
+    @b.intersect(@a, true).sql.should == "SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+    @b.intersect(@a, :all=>true).sql.should == "SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
   end
 
   specify "should support EXCEPT and EXCEPT ALL" do
-    @a.except(@b).sql.should == \
-      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2)) AS t1"
-    @b.except(@a, true).sql.should == \
-      "SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
-    @b.except(@a, :all=>true).sql.should == \
-      "SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+    @a.except(@b).sql.should == "SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2)) AS t1"
+    @b.except(@a, true).sql.should == "SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+    @b.except(@a, :all=>true).sql.should == "SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
   end
     
   specify "should support :alias option for specifying identifier" do
-    @a.union(@b, :alias=>:xx).sql.should == \
-      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2)) AS xx"
-    @a.intersect(@b, :alias=>:xx).sql.should == \
-      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT SELECT * FROM b WHERE (z = 2)) AS xx"
-    @a.except(@b, :alias=>:xx).sql.should == \
-      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2)) AS xx"
+    @a.union(@b, :alias=>:xx).sql.should == "SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2)) AS xx"
+    @a.intersect(@b, :alias=>:xx).sql.should == "SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT SELECT * FROM b WHERE (z = 2)) AS xx"
+    @a.except(@b, :alias=>:xx).sql.should == "SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2)) AS xx"
   end
 
   specify "should support :from_self=>false option to not wrap the compound in a SELECT * FROM (...)" do
-    @b.union(@a, :from_self=>false).sql.should == \
-      "SELECT * FROM b WHERE (z = 2) UNION SELECT * FROM a WHERE (z = 1)"
-    @b.intersect(@a, :from_self=>false).sql.should == \
-      "SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1)"
-    @b.except(@a, :from_self=>false).sql.should == \
-      "SELECT * FROM b WHERE (z = 2) EXCEPT SELECT * FROM a WHERE (z = 1)"
+    @b.union(@a, :from_self=>false).sql.should == "SELECT * FROM b WHERE (z = 2) UNION SELECT * FROM a WHERE (z = 1)"
+    @b.intersect(@a, :from_self=>false).sql.should == "SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1)"
+    @b.except(@a, :from_self=>false).sql.should == "SELECT * FROM b WHERE (z = 2) EXCEPT SELECT * FROM a WHERE (z = 1)"
       
-    @b.union(@a, :from_self=>false, :all=>true).sql.should == \
-      "SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)"
-    @b.intersect(@a, :from_self=>false, :all=>true).sql.should == \
-      "SELECT * FROM b WHERE (z = 2) INTERSECT ALL SELECT * FROM a WHERE (z = 1)"
-    @b.except(@a, :from_self=>false, :all=>true).sql.should == \
-      "SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)"
+    @b.union(@a, :from_self=>false, :all=>true).sql.should == "SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)"
+    @b.intersect(@a, :from_self=>false, :all=>true).sql.should == "SELECT * FROM b WHERE (z = 2) INTERSECT ALL SELECT * FROM a WHERE (z = 1)"
+    @b.except(@a, :from_self=>false, :all=>true).sql.should == "SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)"
   end
 
   specify "should raise an InvalidOperation if INTERSECT or EXCEPT is used and they are not supported" do
@@ -2480,141 +2434,105 @@ describe "Dataset compound operations" do
   end
     
   specify "should handle chained compound operations" do
-    @a.union(@b).union(@a, true).sql.should == \
-      "SELECT * FROM (SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2)) AS t1 UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1"
-    @a.intersect(@b, true).intersect(@a).sql.should == \
-      "SELECT * FROM (SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM b WHERE (z = 2)) AS t1 INTERSECT SELECT * FROM a WHERE (z = 1)) AS t1"
-    @a.except(@b).except(@a, true).sql.should == \
-      "SELECT * FROM (SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2)) AS t1 EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+    @a.union(@b).union(@a, true).sql.should == "SELECT * FROM (SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2)) AS t1 UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1"
+    @a.intersect(@b, true).intersect(@a).sql.should == "SELECT * FROM (SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM b WHERE (z = 2)) AS t1 INTERSECT SELECT * FROM a WHERE (z = 1)) AS t1"
+    @a.except(@b).except(@a, true).sql.should == "SELECT * FROM (SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2)) AS t1 EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
   end
   
   specify "should use a subselect when using a compound operation with a dataset that already has a compound operation" do
-    @a.union(@b.union(@a, true)).sql.should == \
-      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM (SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1) AS t1"
-    @a.intersect(@b.intersect(@a), true).sql.should == \
-      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1)) AS t1) AS t1"
-    @a.except(@b.except(@a, true)).sql.should == \
-      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1) AS t1"
+    @a.union(@b.union(@a, true)).sql.should == "SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM (SELECT * FROM b WHERE (z = 2) UNION ALL SELECT * FROM a WHERE (z = 1)) AS t1) AS t1"
+    @a.intersect(@b.intersect(@a), true).sql.should == "SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT ALL SELECT * FROM (SELECT * FROM b WHERE (z = 2) INTERSECT SELECT * FROM a WHERE (z = 1)) AS t1) AS t1"
+    @a.except(@b.except(@a, true)).sql.should == "SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1) AS t1"
   end
 
   specify "should order and limit properly when using UNION, INTERSECT, or EXCEPT" do
     @dataset = Sequel::Dataset.new(nil).from(:test)
-    @dataset.union(@dataset).limit(2).sql.should ==
-      "SELECT * FROM (SELECT * FROM test UNION SELECT * FROM test) AS t1 LIMIT 2"
-    @dataset.limit(2).intersect(@dataset).sql.should == 
-      "SELECT * FROM (SELECT * FROM (SELECT * FROM test LIMIT 2) AS t1 INTERSECT SELECT * FROM test) AS t1"
-    @dataset.except(@dataset.limit(2)).sql.should == 
-      "SELECT * FROM (SELECT * FROM test EXCEPT SELECT * FROM (SELECT * FROM test LIMIT 2) AS t1) AS t1"
-
-    @dataset.union(@dataset).order(:num).sql.should ==
-      "SELECT * FROM (SELECT * FROM test UNION SELECT * FROM test) AS t1 ORDER BY num"
-    @dataset.order(:num).intersect(@dataset).sql.should == 
-      "SELECT * FROM (SELECT * FROM (SELECT * FROM test ORDER BY num) AS t1 INTERSECT SELECT * FROM test) AS t1"
-    @dataset.except(@dataset.order(:num)).sql.should == 
-      "SELECT * FROM (SELECT * FROM test EXCEPT SELECT * FROM (SELECT * FROM test ORDER BY num) AS t1) AS t1"
+    @dataset.union(@dataset).limit(2).sql.should == "SELECT * FROM (SELECT * FROM test UNION SELECT * FROM test) AS t1 LIMIT 2"
+    @dataset.limit(2).intersect(@dataset).sql.should == "SELECT * FROM (SELECT * FROM (SELECT * FROM test LIMIT 2) AS t1 INTERSECT SELECT * FROM test) AS t1"
+    @dataset.except(@dataset.limit(2)).sql.should == "SELECT * FROM (SELECT * FROM test EXCEPT SELECT * FROM (SELECT * FROM test LIMIT 2) AS t1) AS t1"
+
+    @dataset.union(@dataset).order(:num).sql.should == "SELECT * FROM (SELECT * FROM test UNION SELECT * FROM test) AS t1 ORDER BY num"
+    @dataset.order(:num).intersect(@dataset).sql.should == "SELECT * FROM (SELECT * FROM (SELECT * FROM test ORDER BY num) AS t1 INTERSECT SELECT * FROM test) AS t1"
+    @dataset.except(@dataset.order(:num)).sql.should == "SELECT * FROM (SELECT * FROM test EXCEPT SELECT * FROM (SELECT * FROM test ORDER BY num) AS t1) AS t1"
 
     @dataset.limit(2).order(:a).union(@dataset.limit(3).order(:b)).order(:c).limit(4).sql.should ==
       "SELECT * FROM (SELECT * FROM (SELECT * FROM test ORDER BY a LIMIT 2) AS t1 UNION SELECT * FROM (SELECT * FROM test ORDER BY b LIMIT 3) AS t1) AS t1 ORDER BY c LIMIT 4"
   end
 
+  specify "should hoist WITH clauses in given dataset if dataset doesn't support WITH in subselect" do
+    ds = Sequel::Dataset.new(nil)
+    ds.meta_def(:supports_cte?){true}
+    ds.meta_def(:supports_cte_in_subselect?){false}
+    ds.from(:a).union(ds.from(:c).with(:c, ds.from(:d)), :from_self=>false).sql.should == '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.should == '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.should == 'WITH a AS (SELECT * FROM b), c AS (SELECT * FROM d) SELECT * FROM a INTERSECT SELECT * FROM c'
+  end
 end
 
 describe "Dataset#[]" do
   before do
-    @c = Class.new(Sequel::Dataset) do
-      class_variable_set(:@@last_dataset, nil)
-      
-      def self.last_dataset
-        class_variable_get(:@@last_dataset)
-      end
-
-      def single_record
-        self.class.send(:class_variable_set, :@@last_dataset, opts ? clone(opts) : self)
-        {1 => 2, 3 => 4}
-      end
-    end
-    @d = @c.new(nil).from(:test)
+    @db = Sequel.mock(:fetch=>{1 => 2, 3 => 4})
+    @d = @db[:items]
   end
   
   specify "should return a single record filtered according to the given conditions" do
     @d[:name => 'didi'].should == {1 => 2, 3 => 4}
-    @c.last_dataset.literal(@c.last_dataset.opts[:where]).should == "(name = 'didi')"
+    @db.sqls.should == ["SELECT * FROM items WHERE (name = 'didi') LIMIT 1"]
 
     @d[:id => 5..45].should == {1 => 2, 3 => 4}
-    @c.last_dataset.literal(@c.last_dataset.opts[:where]).should == "((id >= 5) AND (id <= 45))"
+    @db.sqls.should == ["SELECT * FROM items WHERE ((id >= 5) AND (id <= 45)) LIMIT 1"]
   end
 end
 
 describe "Dataset#single_record" do
   before do
-    @c = Class.new(Sequel::Dataset) do
-      def fetch_rows(sql)
-        yield sql
-      end
-    end
-    @cc = Class.new(@c) do
-      def fetch_rows(sql); end
-    end
-    
-    @d = @c.new(nil).from(:test)
-    @e = @cc.new(nil).from(:test)
+    @db = Sequel.mock
   end
   
   specify "should call each with a limit of 1 and return the record" do
-    @d.single_record.should == 'SELECT * FROM test LIMIT 1'
+    @db.fetch = {:a=>1}
+    @db[:test].single_record.should == {:a=>1}
+    @db.sqls.should == ['SELECT * FROM test LIMIT 1']
   end
   
   specify "should return nil if no record is present" do
-    @e.single_record.should be_nil
+    @db[:test].single_record.should be_nil
+    @db.sqls.should == ['SELECT * FROM test LIMIT 1']
   end
 end
 
 describe "Dataset#single_value" do
   before do
-    @c = Class.new(Sequel::Dataset) do
-      def fetch_rows(sql)
-        yield({1 => sql})
-      end
-    end
-    @cc = Class.new(@c) do
-      def fetch_rows(sql); end
-    end
-    
-    @d = @c.new(nil).from(:test)
-    @e = @cc.new(nil).from(:test)
+    @db = Sequel.mock
   end
   
   specify "should call each and return the first value of the first record" do
-    @d.single_value.should == 'SELECT * FROM test LIMIT 1'
+    @db.fetch = {:a=>1}
+    @db[:test].single_value.should == 1
+    @db.sqls.should == ['SELECT * FROM test LIMIT 1']
   end
   
   specify "should return nil if no records" do
-    @e.single_value.should be_nil
+    @db[:test].single_value.should be_nil
+    @db.sqls.should == ['SELECT * FROM test LIMIT 1']
   end
   
   it "should work on a graphed_dataset" do
-    @d.should_receive(:columns).twice.and_return([:a])
-    @d.graph(@d, [:a], :table_alias=>:test2).single_value.should == 'SELECT test.a, test2.a AS test2_a FROM test LEFT OUTER JOIN test AS test2 USING (a) LIMIT 1'
+    @db.fetch = {:a=>1}
+    ds = @db[:test].columns(:a)
+    ds.graph(ds, [:a], :table_alias=>:test2).single_value.should == 1
+    @db.sqls.should == ['SELECT test.a, test2.a AS test2_a FROM test LEFT OUTER JOIN test AS test2 USING (a) LIMIT 1']
   end
 end
 
 describe "Dataset#get" do
   before do
-    @c = Class.new(Sequel::Dataset) do
-      attr_reader :last_sql
-      
-      def fetch_rows(sql)
-        @last_sql = sql
-        yield(:name => sql)
-      end
-    end
-    
-    @d = @c.new(nil).from(:test)
+    @d = Sequel.mock(:fetch=>proc{|s| {:name=>s}})[:test]
   end
   
   specify "should select the specified column and fetch its value" do
     @d.get(:name).should == "SELECT name FROM test LIMIT 1"
-    @d.get(:abc).should == "SELECT abc FROM test LIMIT 1" # the first available value is returned always
+    @d.get(:abc).should == "SELECT abc FROM test LIMIT 1"
   end
   
   specify "should work with filters" do
@@ -2637,239 +2555,244 @@ end
 
 describe "Dataset#set_row_proc" do
   before do
-    @c = Class.new(Sequel::Dataset) do
-      def fetch_rows(sql, &block)
-        # yield a hash with kind as the 1 bit of a number
-        (1..10).each {|i| block.call({:kind => i[0]})}
-      end
-    end
-    @dataset = @c.new(nil).from(:items)
+    @db = Sequel.mock(:fetch=>[{:a=>1}, {:a=>2}])
+    @dataset = @db[:items]
+    @dataset.row_proc = proc{|h| h[:der] = h[:a] + 2; h}
   end
   
   specify "should cause dataset to pass all rows through the filter" do
-    @dataset.row_proc = proc{|h| h[:der] = h[:kind] + 2; h}
-    
     rows = @dataset.all
-    rows.size.should == 10
-    
-    rows.each {|r| r[:der].should == (r[:kind] + 2)}
+    rows.map{|h| h[:der]}.should == [3, 4]
+    @db.sqls.should == ['SELECT * FROM items']
   end
   
   specify "should be copied over when dataset is cloned" do
-    @dataset.row_proc = proc{|h| h[:der] = h[:kind] + 2; h}
-    
-    @dataset.filter(:a => 1).first.should == {:kind => 1, :der => 3}
+    @dataset.filter(:a => 1).all.should == [{:a=>1, :der=>3}, {:a=>2, :der=>4}]
   end
 end
 
 describe "Dataset#<<" do
   before do
-    @d = Sequel::Dataset.new(nil)
-    @d.meta_def(:insert) do |*args|
-      1234567890
-    end
+    @db = Sequel.mock
   end
-  
+
   specify "should call #insert" do
-    (@d << {:name => 1}).should == 1234567890
+    @db[:items] << {:name => 1}
+    @db.sqls.should == ['INSERT INTO items (name) VALUES (1)']
+  end
+
+  specify "should be chainable" do
+    @db[:items] << {:name => 1} << @db[:old_items].select(:name)
+    @db.sqls.should == ['INSERT INTO items (name) VALUES (1)', 'INSERT INTO items SELECT name FROM old_items']
   end
 end
 
 describe "Dataset#columns" do
   before do
-    @dataset = DummyDataset.new(nil).from(:items)
-    @dataset.meta_def(:columns=) {|c| @columns = c}
-    i = 'a' 
-    @dataset.meta_def(:each){@columns = select_sql + i; i = i.next}
+    @dataset = Sequel.mock[:items]
   end
   
   specify "should return the value of @columns if @columns is not nil" do
-    @dataset.columns = [:a, :b, :c]
-    @dataset.columns.should == [:a, :b, :c]
+    @dataset.columns(:a, :b, :c).columns.should == [:a, :b, :c]
+    @dataset.db.sqls.should == []
   end
   
   specify "should attempt to get a single record and return @columns if @columns is nil" do
-    @dataset.columns = nil
-    @dataset.columns.should == 'SELECT * FROM items LIMIT 1a'
-    @dataset.opts[:from] = [:nana]
-    @dataset.columns.should == 'SELECT * FROM items LIMIT 1a'
+    @dataset.db.columns = [:a]
+    @dataset.columns.should == [:a]
+    @dataset.db.sqls.should == ['SELECT * FROM items LIMIT 1']
+  end
+  
+  specify "should be cleared if you change the selected columns" do
+    @dataset.db.columns = [[:a], [:b]]
+    @dataset.columns.should == [:a]
+    @dataset.db.sqls.should == ['SELECT * FROM items LIMIT 1']
+    @dataset.columns.should == [:a]
+    @dataset.db.sqls.should == []
+    ds = @dataset.select{foo{}}
+    ds.columns.should == [:b]
+    @dataset.db.sqls.should == ['SELECT foo() FROM items LIMIT 1']
+  end
+  
+  specify "should be cleared if you change the FROM table" do
+    @dataset.db.columns = [[:a], [:b]]
+    @dataset.columns.should == [:a]
+    @dataset.db.sqls.should == ['SELECT * FROM items LIMIT 1']
+    ds = @dataset.from(:foo)
+    ds.columns.should == [:b]
+    @dataset.db.sqls.should == ['SELECT * FROM foo LIMIT 1']
+  end
+  
+  specify "should be cleared if you join a table to the dataset" do
+    @dataset.db.columns = [[:a], [:a, :b]]
+    @dataset.columns.should == [:a]
+    @dataset.db.sqls.should == ['SELECT * FROM items LIMIT 1']
+    ds = @dataset.cross_join(:foo)
+    ds.columns.should == [:a, :b]
+    @dataset.db.sqls.should == ['SELECT * FROM items CROSS JOIN foo LIMIT 1']
+  end
+  
+  specify "should be cleared if you set custom SQL for the dataset" do
+    @dataset.db.columns = [[:a], [:b]]
+    @dataset.columns.should == [:a]
+    @dataset.db.sqls.should == ['SELECT * FROM items LIMIT 1']
+    ds = @dataset.with_sql('SELECT b FROM foo')
+    ds.columns.should == [:b]
+    @dataset.db.sqls.should == ['SELECT b FROM foo']
   end
   
   specify "should ignore any filters, orders, or DISTINCT clauses" do
+    @dataset.db.columns = [:a]
     @dataset.filter!(:b=>100).order!(:b).distinct!
-    @dataset.columns = nil
-    @dataset.columns.should == 'SELECT * FROM items LIMIT 1a'
+    @dataset.columns.should == [:a]
+    @dataset.db.sqls.should == ['SELECT * FROM items LIMIT 1']
   end
 end
 
 describe "Dataset#columns!" do
-  before do
-    @dataset = DummyDataset.new(nil).from(:items)
-    i = 'a' 
-    @dataset.meta_def(:each){@columns = select_sql + i; i = i.next}
-  end
-  
   specify "should always attempt to get a record and return @columns" do
-    @dataset.columns!.should == 'SELECT * FROM items LIMIT 1a'
-    @dataset.columns!.should == 'SELECT * FROM items LIMIT 1b'
-    @dataset.opts[:from] = [:nana]
-    @dataset.columns!.should == 'SELECT * FROM nana LIMIT 1c'
+    ds = Sequel.mock(:columns=>[[:a, :b, :c], [:d, :e, :f]])[:items]
+    ds.columns!.should == [:a, :b, :c]
+    ds.db.sqls.should == ['SELECT * FROM items LIMIT 1']
+    ds.columns!.should == [:d, :e, :f]
+    ds.db.sqls.should == ['SELECT * FROM items LIMIT 1']
   end
 end
 
 describe "Dataset#import" do
   before do
-    @dbc = Class.new(Sequel::Database) do
-      attr_reader :sqls
-      
-      def execute(sql, opts={})
-        @sqls ||= []
-        @sqls << sql
-      end
-      alias execute_dui execute
-      
-      def transaction(opts={})
-        @sqls ||= []
-        @sqls << 'BEGIN'
-        yield
-        @sqls << 'COMMIT'
-      end
-    end
-    @db = @dbc.new
-    
-    @ds = Sequel::Dataset.new(@db).from(:items)
-    
-    @list = [{:name => 'abc'}, {:name => 'def'}, {:name => 'ghi'}]
+    @db = Sequel.mock
+    @ds = @db[:items]
   end
   
+  specify "should return nil without a query if no values" do
+    @ds.import(['x', 'y'], []).should == nil
+    @db.sqls.should == []
+  end
+
   specify "should accept string keys as column names" do
     @ds.import(['x', 'y'], [[1, 2], [3, 4]])
-    @db.sqls.should == [
-      'BEGIN',
+    @db.sqls.should == ['BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2)",
       "INSERT INTO items (x, y) VALUES (3, 4)",
-      'COMMIT'
-    ]
+      'COMMIT']
   end
 
   specify "should accept a columns array and a values array" do
     @ds.import([:x, :y], [[1, 2], [3, 4]])
-    @db.sqls.should == [
-      'BEGIN',
+    @db.sqls.should == ['BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2)",
       "INSERT INTO items (x, y) VALUES (3, 4)",
-      'COMMIT'
-    ]
+      'COMMIT']
   end
 
   specify "should accept a columns array and a dataset" do
-    @ds2 = Sequel::Dataset.new(@db).from(:cats).filter(:purr => true).select(:a, :b)
+    @ds2 = @ds.from(:cats).filter(:purr => true).select(:a, :b)
     
     @ds.import([:x, :y], @ds2)
-    @db.sqls.should == [
-      'BEGIN',
+    @db.sqls.should == ['BEGIN',
       "INSERT INTO items (x, y) SELECT a, b FROM cats WHERE (purr IS TRUE)",
-      'COMMIT'
-    ]
+      'COMMIT']
   end
 
   specify "should accept a columns array and a values array with :commit_every option" do
     @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :commit_every => 3)
-    @db.sqls.should == [
-      'BEGIN',
+    @db.sqls.should == ['BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2)",
       "INSERT INTO items (x, y) VALUES (3, 4)",
       "INSERT INTO items (x, y) VALUES (5, 6)",
-      'COMMIT',
-    ]
+      'COMMIT']
   end
-  specify "should accept a columns array and a values array with slice option" do
+  specify "should accept a columns array and a values array with :slice option" do
     @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
-    @db.sqls.should == [
-      'BEGIN',
+    @db.sqls.should == ['BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2)",
       "INSERT INTO items (x, y) VALUES (3, 4)",
       'COMMIT',
       'BEGIN',
       "INSERT INTO items (x, y) VALUES (5, 6)",
-      'COMMIT'
-    ]
+      'COMMIT']
   end
 end
 
 describe "Dataset#multi_insert" do
   before do
-    @dbc = Class.new do
-      attr_reader :sqls
-      
-      def execute(sql, opts={})
-        @sqls ||= []
-        @sqls << sql
-      end
-      alias execute_dui execute
-      
-      def transaction(opts={})
-        @sqls ||= []
-        @sqls << 'BEGIN'
-        yield
-        @sqls << 'COMMIT'
-      end
-    end
-    @db = @dbc.new
-    
-    @ds = Sequel::Dataset.new(@db).from(:items)
-    
+    @db = Sequel.mock(:servers=>{:s1=>{}})
+    @ds = @db[:items]
     @list = [{:name => 'abc'}, {:name => 'def'}, {:name => 'ghi'}]
   end
   
+  specify "should return nil without a query if no values" do
+    @ds.multi_insert([]).should == nil
+    @db.sqls.should == []
+  end
+
   specify "should issue multiple insert statements inside a transaction" do
     @ds.multi_insert(@list)
-    @db.sqls.should == [
-      'BEGIN',
+    @db.sqls.should == ['BEGIN',
       "INSERT INTO items (name) VALUES ('abc')",
       "INSERT INTO items (name) VALUES ('def')",
       "INSERT INTO items (name) VALUES ('ghi')",
-      'COMMIT'
-    ]
+      'COMMIT']
+  end
+  
+  specify "should respect :server option" do
+    @ds.multi_insert(@list, :server=>:s1)
+    @db.sqls.should == ['BEGIN -- s1',
+      "INSERT INTO items (name) VALUES ('abc') -- s1",
+      "INSERT INTO items (name) VALUES ('def') -- s1",
+      "INSERT INTO items (name) VALUES ('ghi') -- s1",
+      'COMMIT -- s1']
+  end
+  
+  specify "should respect existing :server option on dataset" do
+    @ds.server(:s1).multi_insert(@list)
+    @db.sqls.should == ['BEGIN -- s1',
+      "INSERT INTO items (name) VALUES ('abc') -- s1",
+      "INSERT INTO items (name) VALUES ('def') -- s1",
+      "INSERT INTO items (name) VALUES ('ghi') -- s1",
+      'COMMIT -- s1']
+  end
+  
+  specify "should respect :return=>:primary_key option" do
+    @db.autoid = 1
+    @ds.multi_insert(@list, :return=>:primary_key).should == [1, 2, 3]
+    @db.sqls.should == ['BEGIN',
+      "INSERT INTO items (name) VALUES ('abc')",
+      "INSERT INTO items (name) VALUES ('def')",
+      "INSERT INTO items (name) VALUES ('ghi')",
+      'COMMIT']
   end
   
   specify "should handle different formats for tables" do
     @ds = @ds.from(:sch__tab)
     @ds.multi_insert(@list)
-    @db.sqls.should == [
-      'BEGIN',
+    @db.sqls.should == ['BEGIN',
       "INSERT INTO sch.tab (name) VALUES ('abc')",
       "INSERT INTO sch.tab (name) VALUES ('def')",
       "INSERT INTO sch.tab (name) VALUES ('ghi')",
-      'COMMIT'
-    ]
-    @db.sqls.clear
+      'COMMIT']
 
     @ds = @ds.from(:tab.qualify(:sch))
     @ds.multi_insert(@list)
-    @db.sqls.should == [
-      'BEGIN',
+    @db.sqls.should == ['BEGIN',
       "INSERT INTO sch.tab (name) VALUES ('abc')",
       "INSERT INTO sch.tab (name) VALUES ('def')",
       "INSERT INTO sch.tab (name) VALUES ('ghi')",
-      'COMMIT'
-    ]
-    @db.sqls.clear
+      'COMMIT']
+
     @ds = @ds.from(:sch__tab.identifier)
     @ds.multi_insert(@list)
-    @db.sqls.should == [
-      'BEGIN',
+    @db.sqls.should == ['BEGIN',
       "INSERT INTO sch__tab (name) VALUES ('abc')",
       "INSERT INTO sch__tab (name) VALUES ('def')",
       "INSERT INTO sch__tab (name) VALUES ('ghi')",
-      'COMMIT'
-    ]
+      'COMMIT']
   end
   
   specify "should accept the :commit_every option for committing every x records" do
     @ds.multi_insert(@list, :commit_every => 1)
-    @db.sqls.should == [
-      'BEGIN',
+    @db.sqls.should == ['BEGIN',
       "INSERT INTO items (name) VALUES ('abc')",
       'COMMIT',
       'BEGIN',
@@ -2877,36 +2800,31 @@ describe "Dataset#multi_insert" do
       'COMMIT',
       'BEGIN',
       "INSERT INTO items (name) VALUES ('ghi')",
-      'COMMIT'
-    ]
+      'COMMIT']
   end
 
   specify "should accept the :slice option for committing every x records" do
     @ds.multi_insert(@list, :slice => 2)
-    @db.sqls.should == [
-      'BEGIN',
+    @db.sqls.should == ['BEGIN',
       "INSERT INTO items (name) VALUES ('abc')",
       "INSERT INTO items (name) VALUES ('def')",
       'COMMIT',
       'BEGIN',
       "INSERT INTO items (name) VALUES ('ghi')",
-      'COMMIT'
-    ]
+      'COMMIT']
   end
   
   specify "should accept string keys as column names" do
     @ds.multi_insert([{'x'=>1, 'y'=>2}, {'x'=>3, 'y'=>4}])
-    @db.sqls.should == [
-      'BEGIN',
-      "INSERT INTO items (x, y) VALUES (1, 2)",
-      "INSERT INTO items (x, y) VALUES (3, 4)",
-      'COMMIT'
-    ]
+    sqls = @db.sqls
+    ["INSERT INTO items (x, y) VALUES (1, 2)", "INSERT INTO items (y, x) VALUES (2, 1)"].should include(sqls.slice!(1))
+    ["INSERT INTO items (x, y) VALUES (3, 4)", "INSERT INTO items (y, x) VALUES (4, 3)"].should include(sqls.slice!(1))
+    sqls.should == ['BEGIN', 'COMMIT']
   end
 
   specify "should not do anything if no hashes are provided" do
     @ds.multi_insert([])
-    @db.sqls.should be_nil
+    @db.sqls.should == []
   end
 end
 
@@ -2951,41 +2869,21 @@ describe "Dataset" do
   end
   
   specify "should support chaining of bang methods" do
-      @d.order!(:y)
-      @d.filter!(:y => 1)
-      @d.sql.should == "SELECT * FROM x WHERE (y = 1) ORDER BY y"
+      @d.order!(:y).filter!(:y => 1).sql.should == "SELECT * FROM x WHERE (y = 1) ORDER BY y"
   end
 end
 
 describe "Dataset#to_csv" do
   before do
-    @c = Class.new(Sequel::Dataset) do
-      attr_accessor :data
-      attr_accessor :columns
-      
-      def fetch_rows(sql, &block)
-        @data.each(&block)
-      end
-      
-      # naked should return self here because to_csv wants a naked result set.
-      def naked
-        self
-      end
-    end
-    
-    @ds = @c.new(nil).from(:items)
-    @ds.columns = [:a, :b, :c]
-    @ds.data = [ {:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}, {:a=>7, :b=>8, :c=>9} ]
+    @ds = Sequel.mock(:fetch=>[{:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}, {:a=>7, :b=>8, :c=>9}])[:items].columns(:a, :b, :c)
   end
   
   specify "should format a CSV representation of the records" do
-    @ds.to_csv.should ==
-      "a, b, c\r\n1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
+    @ds.to_csv.should == "a, b, c\r\n1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
   end
 
   specify "should exclude column titles if so specified" do
-    @ds.to_csv(false).should ==
-      "1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
+    @ds.to_csv(false).should == "1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
   end
 end
 
@@ -3083,66 +2981,40 @@ describe "Dataset#insert_sql" do
   end
 end
 
-class DummyMummyDataset < Sequel::Dataset
-  def first
-    raise if @opts[:from] == [:a]
-    true
+describe "Dataset#inspect" do
+  before do
+    class ::InspectDataset < Sequel::Dataset; end
   end
-end
-
-class DummyMummyDatabase < Sequel::Database
-  attr_reader :sqls
-  
-  def execute(sql)
-    @sqls ||= []
-    @sqls << sql
+  after do
+    Object.send(:remove_const, :InspectDataset) if defined?(::InspectDataset)
   end
-  
-  def transaction; yield; end
 
-  def dataset
-    DummyMummyDataset.new(self)
+  specify "should include the class name and the corresponding SQL statement" do
+    Sequel::Dataset.new(nil).from(:blah).inspect.should == '#<Sequel::Dataset: "SELECT * FROM blah">'
+    InspectDataset.new(nil).from(:blah).inspect.should == '#<InspectDataset: "SELECT * FROM blah">'
   end
-end
 
-describe "Dataset#inspect" do
-  before do
-    @ds = Sequel::Dataset.new(nil).from(:blah)
-  end
-  
-  specify "should include the class name and the corresponding SQL statement" do
-    @ds.inspect.should == '#<%s: %s>' % [@ds.class.to_s, @ds.sql.inspect]
+  specify "should skip anonymous classes" do
+    Class.new(Class.new(Sequel::Dataset)).new(nil).from(:blah).inspect.should == '#<Sequel::Dataset: "SELECT * FROM blah">'
+    Class.new(InspectDataset).new(nil).from(:blah).inspect.should == '#<InspectDataset: "SELECT * FROM blah">'
   end
 end
 
 describe "Dataset#all" do
   before do
-    @c = Class.new(Sequel::Dataset) do
-      def fetch_rows(sql, &block)
-        block.call({:x => 1, :y => 2})
-        block.call({:x => 3, :y => 4})
-        block.call(sql)
-      end
-    end
-    @dataset = @c.new(nil).from(:items)
+    @dataset = Sequel.mock(:fetch=>[{:x => 1, :y => 2}, {:x => 3, :y => 4}])[:items]
   end
 
   specify "should return an array with all records" do
-    @dataset.all.should == [
-      {:x => 1, :y => 2},
-      {:x => 3, :y => 4},
-      "SELECT * FROM items"
-    ]
+    @dataset.all.should == [{:x => 1, :y => 2}, {:x => 3, :y => 4}]
+    @dataset.db.sqls.should == ["SELECT * FROM items"]
   end
   
   specify "should iterate over the array if a block is given" do
     a = []
-    
-    @dataset.all do |r|
-      a << (r.is_a?(Hash) ? r[:x] : r)
-    end
-    
-    a.should == [1, 3, "SELECT * FROM items"]
+    @dataset.all{|r| a << r.values_at(:x, :y)}.should == [{:x => 1, :y => 2}, {:x => 3, :y => 4}]
+    a.should == [[1, 2], [3, 4]]
+    @dataset.db.sqls.should == ["SELECT * FROM items"]
   end
 end
 
@@ -3152,71 +3024,56 @@ describe "Dataset#grep" do
   end
   
   specify "should format a SQL filter correctly" do
-    @ds.grep(:title, 'ruby').sql.should ==
-      "SELECT * FROM posts WHERE ((title LIKE 'ruby'))"
+    @ds.grep(:title, 'ruby').sql.should == "SELECT * FROM posts WHERE ((title LIKE 'ruby'))"
   end
 
   specify "should support multiple columns" do
-    @ds.grep([:title, :body], 'ruby').sql.should ==
-      "SELECT * FROM posts WHERE ((title LIKE 'ruby') OR (body LIKE 'ruby'))"
+    @ds.grep([:title, :body], 'ruby').sql.should == "SELECT * FROM posts WHERE ((title LIKE 'ruby') OR (body LIKE 'ruby'))"
   end
   
   specify "should support multiple search terms" do
-    @ds.grep(:title, ['abc', 'def']).sql.should == 
-      "SELECT * FROM posts WHERE ((title LIKE 'abc') OR (title LIKE 'def'))"
+    @ds.grep(:title, ['abc', 'def']).sql.should == "SELECT * FROM posts WHERE ((title LIKE 'abc') OR (title LIKE 'def'))"
   end
   
   specify "should support multiple columns and search terms" do
-    @ds.grep([:title, :body], ['abc', 'def']).sql.should ==
-      "SELECT * FROM posts WHERE ((title LIKE 'abc') OR (title LIKE 'def') OR (body LIKE 'abc') OR (body LIKE 'def'))"
+    @ds.grep([:title, :body], ['abc', 'def']).sql.should == "SELECT * FROM posts WHERE ((title LIKE 'abc') OR (title LIKE 'def') OR (body LIKE 'abc') OR (body LIKE 'def'))"
   end
   
   specify "should support the :all_patterns option" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true).sql.should ==
-      "SELECT * FROM posts WHERE (((title LIKE 'abc') OR (body LIKE 'abc')) AND ((title LIKE 'def') OR (body LIKE 'def')))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true).sql.should == "SELECT * FROM posts WHERE (((title LIKE 'abc') OR (body LIKE 'abc')) AND ((title LIKE 'def') OR (body LIKE 'def')))"
   end
   
   specify "should support the :all_columns option" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_columns=>true).sql.should ==
-      "SELECT * FROM posts WHERE (((title LIKE 'abc') OR (title LIKE 'def')) AND ((body LIKE 'abc') OR (body LIKE 'def')))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_columns=>true).sql.should == "SELECT * FROM posts WHERE (((title LIKE 'abc') OR (title LIKE 'def')) AND ((body LIKE 'abc') OR (body LIKE 'def')))"
   end
   
   specify "should support the :case_insensitive option" do
-    @ds.grep([:title, :body], ['abc', 'def'], :case_insensitive=>true).sql.should ==
-      "SELECT * FROM posts WHERE ((title ILIKE 'abc') OR (title ILIKE 'def') OR (body ILIKE 'abc') OR (body ILIKE 'def'))"
+    @ds.grep([:title, :body], ['abc', 'def'], :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE ((title ILIKE 'abc') OR (title ILIKE 'def') OR (body ILIKE 'abc') OR (body ILIKE 'def'))"
   end
   
   specify "should support the :all_patterns and :all_columns options together" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :all_columns=>true).sql.should ==
-      "SELECT * FROM posts WHERE ((title LIKE 'abc') AND (body LIKE 'abc') AND (title LIKE 'def') AND (body LIKE 'def'))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :all_columns=>true).sql.should == "SELECT * FROM posts WHERE ((title LIKE 'abc') AND (body LIKE 'abc') AND (title LIKE 'def') AND (body LIKE 'def'))"
   end
   
   specify "should support the :all_patterns and :case_insensitive options together" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :case_insensitive=>true).sql.should ==
-      "SELECT * FROM posts WHERE (((title ILIKE 'abc') OR (body ILIKE 'abc')) AND ((title ILIKE 'def') OR (body ILIKE 'def')))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE (((title ILIKE 'abc') OR (body ILIKE 'abc')) AND ((title ILIKE 'def') OR (body ILIKE 'def')))"
   end
   
   specify "should support the :all_columns and :case_insensitive options together" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_columns=>true, :case_insensitive=>true).sql.should ==
-      "SELECT * FROM posts WHERE (((title ILIKE 'abc') OR (title ILIKE 'def')) AND ((body ILIKE 'abc') OR (body ILIKE 'def')))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_columns=>true, :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE (((title ILIKE 'abc') OR (title ILIKE 'def')) AND ((body ILIKE 'abc') OR (body ILIKE 'def')))"
   end
   
   specify "should support the :all_patterns, :all_columns, and :case_insensitive options together" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :all_columns=>true, :case_insensitive=>true).sql.should ==
-      "SELECT * FROM posts WHERE ((title ILIKE 'abc') AND (body ILIKE 'abc') AND (title ILIKE 'def') AND (body ILIKE 'def'))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :all_columns=>true, :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE ((title ILIKE 'abc') AND (body ILIKE 'abc') AND (title ILIKE 'def') AND (body ILIKE 'def'))"
   end
 
   specify "should support regexps though the database may not support it" do
-    @ds.grep(:title, /ruby/).sql.should ==
-      "SELECT * FROM posts WHERE ((title ~ 'ruby'))"
-
-    @ds.grep(:title, [/^ruby/, 'ruby']).sql.should ==
-      "SELECT * FROM posts WHERE ((title ~ '^ruby') OR (title LIKE 'ruby'))"
+    @ds.grep(:title, /ruby/).sql.should == "SELECT * FROM posts WHERE ((title ~ 'ruby'))"
+    @ds.grep(:title, [/^ruby/, 'ruby']).sql.should == "SELECT * FROM posts WHERE ((title ~ '^ruby') OR (title LIKE 'ruby'))"
   end
 
   specify "should support searching against other columns" do
-    @ds.grep(:title, :body).sql.should ==
-      "SELECT * FROM posts WHERE ((title LIKE body))"
+    @ds.grep(:title, :body).sql.should == "SELECT * FROM posts WHERE ((title LIKE body))"
   end
 end
 
@@ -3270,58 +3127,63 @@ end
 
 describe "Dataset prepared statements and bound variables " do
   before do
-    @db = Sequel::Database.new
-    @db.meta_def(:sqls){@sqls||=[]}
-    def @db.execute(sql, opts={})
-      sqls << sql
-    end
-    def @db.dataset
-      ds = super()
-      def ds.fetch_rows(sql, &block)
-        execute(sql)
-      end
-      ds
-    end
+    @db = Sequel.mock
     @ds = @db[:items]
+    @ds.meta_def(:insert_sql){|*v| "#{super(*v)}#{' RETURNING *' if opts.has_key?(:returning)}" }
   end
   
   specify "#call should take a type and bind hash and interpolate it" do
     @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)
     @ds.filter(:num=>:$n).call(:first, :n=>1)
     @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_select, {:n=>1}, :num=>:$n)
     @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1) LIMIT 1',
       'DELETE FROM items WHERE (num = 1)',
       'UPDATE items SET num = 2 WHERE (num = 1)',
-      'INSERT INTO items (num) VALUES (1)']
+      'INSERT INTO items (num) VALUES (1)',
+      'INSERT INTO items (num) VALUES (1) RETURNING *']
   end
     
   specify "#prepare should take a type and name and store it in the database for later use with call" do
     pss = []
     pss << @ds.filter(:num=>:$n).prepare(:select, :sn)
+    pss << @ds.filter(:num=>:$n).prepare([:map, :a], :sm)
+    pss << @ds.filter(:num=>:$n).prepare([:to_hash, :a, :b], :sh)
     pss << @ds.filter(:num=>:$n).prepare(:first, :fn)
     pss << @ds.filter(:num=>:$n).prepare(:delete, :dn)
     pss << @ds.filter(:num=>:$n).prepare(:update, :un, :num=>:$n2)
     pss << @ds.prepare(:insert, :in, :num=>:$n)
-    @db.prepared_statements.keys.sort_by{|k| k.to_s}.should == [:dn, :fn, :in, :sn, :un]
-    [:sn, :fn, :dn, :un, :in].each_with_index{|x, i| @db.prepared_statements[x].should == pss[i]}
+    pss << @ds.prepare(:insert_select, :ins, :num=>:$n)
+    @db.prepared_statements.keys.sort_by{|k| k.to_s}.should == [:dn, :fn, :in, :ins, :sh, :sm, :sn, :un]
+    [:sn, :sm, :sh, :fn, :dn, :un, :in, :ins].each_with_index{|x, i| @db.prepared_statements[x].should == pss[i]}
     @db.call(:sn, :n=>1)
+    @db.call(:sm, :n=>1)
+    @db.call(:sh, :n=>1)
     @db.call(:fn, :n=>1)
     @db.call(:dn, :n=>1)
     @db.call(:un, :n=>1, :n2=>2)
     @db.call(:in, :n=>1)
+    @db.call(:ins, :n=>1)
     @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1) LIMIT 1',
       'DELETE FROM items WHERE (num = 1)',
       'UPDATE items SET num = 2 WHERE (num = 1)',
-      'INSERT INTO items (num) VALUES (1)']
+      'INSERT INTO items (num) VALUES (1)',
+      'INSERT INTO items (num) VALUES (1) RETURNING *']
   end
     
   specify "#inspect should indicate it is a prepared statement with the prepared SQL" do
     @ds.filter(:num=>:$n).prepare(:select, :sn).inspect.should == \
-      '<Sequel::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = $n)">'
+      '<Sequel::Mock::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = $n)">'
   end
     
   specify "should handle literal strings" do
@@ -3329,6 +3191,13 @@ describe "Dataset prepared statements and bound variables " do
     @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)']
   end
     
+  specify "should handle columns on prepared statements correctly" do
+    @db.columns = [:num]
+    @ds.meta_def(:select_where_sql){|sql| super(sql); sql << " OR #{columns.first} = 1" if opts[:where]}
+    @ds.filter(:num=>:$n).prepare(:select, :sn).sql.should == 'SELECT * FROM items WHERE (num = $n) OR num = 1'
+    @db.sqls.should == ['SELECT * FROM items LIMIT 1']
+  end
+    
   specify "should handle datasets using static sql and placeholders" do
     @db["SELECT * FROM items WHERE (num = ?)", :$n].call(:select, :n=>1)
     @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)']
@@ -3357,23 +3226,16 @@ end
 
 describe Sequel::Dataset::UnnumberedArgumentMapper do
   before do
-    @db = Sequel::Database.new
-    @db.meta_def(:sqls){@sqls||=[]}
-    def @db.execute(sql, opts={})
-      sqls << [sql, *opts[:arguments]]
-    end
+    @db = Sequel.mock
     @ds = @db[:items].filter(:num=>:$n)
-    def @ds.fetch_rows(sql, &block)
-      execute(sql)
-    end
     def @ds.execute(sql, opts={}, &block)
-      @db.execute(sql, {:arguments=>bind_arguments}.merge(opts))
+      super(sql, opts.merge({:arguments=>bind_arguments}), &block)
     end
-    def @ds.execute_dui(*args, &block)
-      execute(*args, &block)
+    def @ds.execute_dui(sql, opts={}, &block)
+      super(sql, opts.merge({:arguments=>bind_arguments}), &block)
     end
-    def @ds.execute_insert(*args, &block)
-      execute(*args, &block)
+    def @ds.execute_insert(sql, opts={}, &block)
+      super(sql, opts.merge({:arguments=>bind_arguments}), &block)
     end
     @ps = []
     @ps << @ds.prepare(:select, :s)
@@ -3386,64 +3248,43 @@ describe Sequel::Dataset::UnnumberedArgumentMapper do
   end
 
   specify "#inspect should show the actual SQL submitted to the database" do
-    @ps.first.inspect.should == '<Sequel::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = ?)">'
+    @ps.first.inspect.should == '<Sequel::Mock::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = ?)">'
   end
   
   specify "should submitted the SQL to the database with placeholders and bind variables" do
     @ps.each{|p| p.prepared_sql; p.call(:n=>1)}
-    @db.sqls.should == [["SELECT * FROM items WHERE (num = ?)", 1],
-      ["SELECT * FROM items WHERE (num = ?)", 1],
-      ["SELECT * FROM items WHERE (num = ?) LIMIT 1", 1],
-      ["DELETE FROM items WHERE (num = ?)", 1],
-      ["INSERT INTO items (num) VALUES (?)", 1],
-      ["UPDATE items SET num = ? WHERE (num = ?)", 1, 1],
-      ]
+    @db.sqls.should == ["SELECT * FROM items WHERE (num = ?) -- args: [1]",
+      "SELECT * FROM items WHERE (num = ?) -- args: [1]",
+      "SELECT * FROM items WHERE (num = ?) LIMIT 1 -- args: [1]",
+      "DELETE FROM items WHERE (num = ?) -- args: [1]",
+      "INSERT INTO items (num) VALUES (?) -- args: [1]",
+      "UPDATE items SET num = ? WHERE (num = ?) -- args: [1, 1]"]
   end
 end
 
 describe "Sequel::Dataset#server" do
   specify "should set the server to use for the dataset" do
-    @db = Sequel::Database.new
+    @db = Sequel.mock(:servers=>{:s=>{}, :i=>{}, :d=>{}, :u=>{}})
     @ds = @db[:items].server(:s)
-    sqls = []
-    @db.meta_def(:execute) do |sql, opts|
-      sqls << [sql, opts[:server]]
-    end
-    def @ds.fetch_rows(sql, &block)
-      execute(sql)
-    end
     @ds.all
     @ds.server(:i).insert(:a=>1)
     @ds.server(:d).delete
     @ds.server(:u).update(:a=>:a+1)
-    sqls.should == [['SELECT * FROM items', :s],
-      ['INSERT INTO items (a) VALUES (1)', :i],
-      ['DELETE FROM items', :d],
-      ['UPDATE items SET a = (a + 1)', :u]]
+    @db.sqls.should == ['SELECT * FROM items -- s', 'INSERT INTO items (a) VALUES (1) -- i', 'DELETE FROM items -- d', 'UPDATE items SET a = (a + 1) -- u']
   end
 end
 
 describe "Sequel::Dataset#each_server" do
-  before do
-    @db = Sequel::Database.new(:servers=>{:s=>{}, :i=>{}})
-    @ds = @db[:items]
-    sqls = @sqls = []
-    @db.meta_def(:execute) do |sql, opts|
-      sqls << [sql, opts[:server]]
-    end
-    def @ds.fetch_rows(sql, &block)
-      execute(sql)
-    end
-  end
-
   specify "should yield a dataset for each server" do
+    @db = Sequel.mock(:servers=>{:s=>{}, :i=>{}})
+    @ds = @db[:items]
     @ds.each_server do |ds|
       ds.should be_a_kind_of(Sequel::Dataset)
       ds.should_not == @ds
       ds.sql.should == @ds.sql
       ds.all
     end
-    @sqls.sort_by{|sql, s| s.to_s}.should == [['SELECT * FROM items', :default], ['SELECT * FROM items', :i], ['SELECT * FROM items', :s]]
+    @db.sqls.sort.should == ['SELECT * FROM items', 'SELECT * FROM items -- i', 'SELECT * FROM items -- s']
   end
 end
 
@@ -3493,23 +3334,23 @@ end
 
 describe "Sequel::Dataset#qualify" do
   specify "should qualify to the given table" do
-    MockDatabase.new[:t].filter{a<b}.qualify(:e).sql.should == 'SELECT e.* FROM t WHERE (e.a < e.b)'
+    Sequel::Dataset.new(nil).from(:t).filter{a<b}.qualify(:e).sql.should == 'SELECT e.* FROM t WHERE (e.a < e.b)'
   end
 
   specify "should qualify to the first source if no table if given" do
-    MockDatabase.new[:t].filter{a<b}.qualify.sql.should == 'SELECT t.* FROM t WHERE (t.a < t.b)'
+    Sequel::Dataset.new(nil).from(:t).filter{a<b}.qualify.sql.should == 'SELECT t.* FROM t WHERE (t.a < t.b)'
   end
 end
 
 describe "Sequel::Dataset#qualify_to" do
   specify "should qualify to the given table" do
-    MockDatabase.new[:t].filter{a<b}.qualify_to(:e).sql.should == 'SELECT e.* FROM t WHERE (e.a < e.b)'
+    Sequel::Dataset.new(nil).from(:t).filter{a<b}.qualify_to(:e).sql.should == 'SELECT e.* FROM t WHERE (e.a < e.b)'
   end
 end
 
 describe "Sequel::Dataset#qualify_to_first_source" do
   before do
-    @ds = MockDatabase.new[:t]
+    @ds = Sequel::Database.new[:t]
   end
 
   specify "should qualify_to the first source" do
@@ -3519,13 +3360,11 @@ describe "Sequel::Dataset#qualify_to_first_source" do
   end
 
   specify "should handle the select, order, where, having, and group options/clauses" do
-    @ds.select(:a).filter(:a=>1).order(:a).group(:a).having(:a).qualify_to_first_source.sql.should == \
-      'SELECT t.a FROM t WHERE (t.a = 1) GROUP BY t.a HAVING t.a ORDER BY t.a'
+    @ds.select(:a).filter(:a=>1).order(:a).group(:a).having(:a).qualify_to_first_source.sql.should == 'SELECT t.a FROM t WHERE (t.a = 1) GROUP BY t.a HAVING t.a ORDER BY t.a'
   end
 
   specify "should handle the select using a table.* if all columns are currently selected" do
-    @ds.filter(:a=>1).order(:a).group(:a).having(:a).qualify_to_first_source.sql.should == \
-      'SELECT t.* FROM t WHERE (t.a = 1) GROUP BY t.a HAVING t.a ORDER BY t.a'
+    @ds.filter(:a=>1).order(:a).group(:a).having(:a).qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE (t.a = 1) GROUP BY t.a HAVING t.a ORDER BY t.a'
   end
 
   specify "should handle hashes in select option" do
@@ -3594,14 +3433,83 @@ describe "Sequel::Dataset#qualify_to_first_source" do
   end
 
   specify "should handle all other objects by returning them unchanged" do
-    @ds.select("a").filter{a(3)}.filter('blah').order('true'.lit).group('a > ?'.lit(1)).having(false).qualify_to_first_source.sql.should == \
-      "SELECT 'a' FROM t WHERE (a(3) AND (blah)) GROUP BY a > 1 HAVING 'f' ORDER BY true"
+    @ds.select("a").filter{a(3)}.filter('blah').order('true'.lit).group('a > ?'.lit(1)).having(false).qualify_to_first_source.sql.should == "SELECT 'a' FROM t WHERE (a(3) AND (blah)) GROUP BY a > 1 HAVING 'f' ORDER BY true"
+  end
+end
+
+describe "Sequel::Dataset#unbind" do
+  before do
+    @ds = Sequel::Database.new[:t]
+    @u = proc{|ds| ds, bv = ds.unbind; [ds.sql, bv]}
+  end
+
+  specify "should unbind values assigned to equality and inequality statements" do
+    @ds.filter(:foo=>1).unbind.first.sql.should == "SELECT * FROM t WHERE (foo = $foo)"
+    @ds.exclude(:foo=>1).unbind.first.sql.should == "SELECT * FROM t WHERE (foo != $foo)"
+    @ds.filter{foo > 1}.unbind.first.sql.should == "SELECT * FROM t WHERE (foo > $foo)"
+    @ds.filter{foo >= 1}.unbind.first.sql.should == "SELECT * FROM t WHERE (foo >= $foo)"
+    @ds.filter{foo < 1}.unbind.first.sql.should == "SELECT * FROM t WHERE (foo < $foo)"
+    @ds.filter{foo <= 1}.unbind.first.sql.should == "SELECT * FROM t WHERE (foo <= $foo)"
+  end
+
+  specify "should return variables that could be used bound to recreate the previous query" do
+    @ds.filter(:foo=>1).unbind.last.should == {:foo=>1}
+    @ds.exclude(:foo=>1).unbind.last.should == {:foo=>1}
+  end
+
+  specify "should handle numerics, strings, dates, times, and datetimes" do
+    @u[@ds.filter(:foo=>1)].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>1}]
+    @u[@ds.filter(:foo=>1.0)].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>1.0}]
+    @u[@ds.filter(:foo=>BigDecimal.new('1.0'))].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>BigDecimal.new('1.0')}]
+    @u[@ds.filter(:foo=>'a')].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>'a'}]
+    @u[@ds.filter(:foo=>Date.today)].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>Date.today}]
+    t = Time.now
+    @u[@ds.filter(:foo=>t)].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>t}]
+    dt = DateTime.now
+    @u[@ds.filter(:foo=>dt)].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>dt}]
+  end
+
+  specify "should not unbind literal strings" do
+    @u[@ds.filter(:foo=>'a'.lit)].should == ["SELECT * FROM t WHERE (foo = a)", {}]
+  end
+
+  specify "should not unbind Identifiers, QualifiedIdentifiers, or Symbols used as booleans" do
+    @u[@ds.filter(:foo).filter{bar}.filter{foo__bar}].should == ["SELECT * FROM t WHERE (foo AND bar AND foo.bar)", {}]
+  end
+
+  specify "should not unbind for values it doesn't understand" do
+    @u[@ds.filter(:foo=>Class.new{def sql_literal(ds) 'bar' end}.new)].should == ["SELECT * FROM t WHERE (foo = bar)", {}]
+  end
+
+  specify "should handle QualifiedIdentifiers" do
+    @u[@ds.filter{foo__bar > 1}].should == ["SELECT * FROM t WHERE (foo.bar > $foo.bar)", {:"foo.bar"=>1}]
+  end
+
+  specify "should handle deep nesting" do
+    @u[@ds.filter{foo > 1}.and{bar < 2}.or(:baz=>3).and({~{:x=>4}=>true}.case(false))].should == ["SELECT * FROM t WHERE ((((foo > $foo) AND (bar < $bar)) OR (baz = $baz)) AND (CASE WHEN (x != $x) THEN 't' ELSE 'f' END))", {:foo=>1, :bar=>2, :baz=>3, :x=>4}]
+  end
+
+  specify "should handle JOIN ON" do
+    @u[@ds.cross_join(:x).join(:a, [:u]).join(:b, [[:c, :d], [:e,1]])].should == ["SELECT * FROM t CROSS JOIN x INNER JOIN a USING (u) INNER JOIN b ON ((b.c = a.d) AND (b.e = $b.e))", {:"b.e"=>1}]
+  end
+
+  specify "should raise an UnbindDuplicate exception if same variable is used with multiple different values" do
+    proc{@ds.filter(:foo=>1).or(:foo=>2).unbind}.should raise_error(Sequel::UnbindDuplicate)
+  end
+
+  specify "should handle case where the same variable has the same value in multiple places " do
+    @u[@ds.filter(:foo=>1).or(:foo=>1)].should == ["SELECT * FROM t WHERE ((foo = $foo) OR (foo = $foo))", {:foo=>1}]
+  end
+
+  specify "should raise Error for unhandled objects inside Identifiers and QualifiedIndentifiers" do
+    proc{@ds.filter(Sequel::SQL::Identifier.new([]) > 1).unbind}.should raise_error(Sequel::Error)
+    proc{@ds.filter{foo.qualify({}) > 1}.unbind}.should raise_error(Sequel::Error)
   end
 end
 
 describe "Sequel::Dataset #with and #with_recursive" do
   before do
-    @db = MockDatabase.new
+    @db = Sequel::Database.new
     @ds = @db[:t]
   end
   
@@ -3633,11 +3541,27 @@ describe "Sequel::Dataset #with and #with_recursive" do
     proc{@ds.with(:t, @db[:x], :args=>[:b])}.should raise_error(Sequel::Error)
     proc{@ds.with_recursive(:t, @db[:x], @db[:t], :args=>[:b, :c])}.should raise_error(Sequel::Error)
   end
+
+  specify "#with should work on insert, update, and delete statements if they support it" do
+    [:insert, :update, :delete].each do |m|
+      @ds.meta_def(:"#{m}_clause_methods"){[:"#{m}_with_sql"] + super()}
+    end
+    @ds.with(:t, @db[:x]).insert_sql(1).should == 'WITH t AS (SELECT * FROM x) INSERT INTO t VALUES (1)'
+    @ds.with(:t, @db[:x]).update_sql(:foo=>1).should == 'WITH t AS (SELECT * FROM x) UPDATE t SET foo = 1'
+    @ds.with(:t, @db[:x]).delete_sql.should == 'WITH t AS (SELECT * FROM x) DELETE FROM t'
+  end
+
+  specify "should hoist WITH clauses in given dataset(s) if dataset doesn't support WITH in subselect" do
+    @ds.meta_def(:supports_cte?){true}
+    @ds.meta_def(:supports_cte_in_subselect?){false}
+    @ds.with(:t, @ds.from(:s).with(:s, @ds.from(:r))).sql.should == '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.should == '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
 end
 
 describe Sequel::SQL::Constants do
   before do
-    @db = MockDatabase.new
+    @db = Sequel::Database.new
   end
   
   it "should have CURRENT_DATE" do
@@ -3682,7 +3606,7 @@ end
 
 describe "Sequel timezone support" do
   before do
-    @db = MockDatabase.new
+    @db = Sequel::Database.new
     @dataset = @db.dataset
     @dataset.meta_def(:supports_timestamp_timezones?){true}
     @dataset.meta_def(:supports_timestamp_usecs?){false}
@@ -3717,6 +3641,30 @@ describe "Sequel timezone support" do
     @dataset.literal(t).should == "#{s}#{@offset}'"
   end
   
+  specify "should have Database#timezone override Sequel.database_timezone" do
+    Sequel.database_timezone = :local
+    @db.timezone = :utc
+
+    t = Time.now
+    s = t.getutc.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}+0000'"
+
+    t = DateTime.now
+    s = t.new_offset(0).strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}+0000'"
+
+    Sequel.database_timezone = :utc
+    @db.timezone = :local
+
+    t = Time.now.utc
+    s = t.getlocal.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}#{@offset}'"
+
+    t = DateTime.now.new_offset(0)
+    s = t.new_offset(DateTime.now.offset).strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}#{@offset}'"
+  end
+  
   specify "should handle converting database timestamps into application timestamps" do
     Sequel.database_timezone = :utc
     Sequel.application_timezone = :local
@@ -3827,13 +3775,7 @@ end
 
 describe "Sequel::Dataset#select_map" do
   before do
-    @ds = MockDatabase.new[:t]
-    def @ds.fetch_rows(sql)
-      db << sql
-      yield({:c=>1})
-      yield({:c=>2})
-    end
-    @ds.db.reset
+    @ds = Sequel.mock(:fetch=>[{:c=>1}, {:c=>2}])[:t]
   end
 
   specify "should do select and map in one step" do
@@ -3846,6 +3788,12 @@ describe "Sequel::Dataset#select_map" do
     @ds.db.sqls.should == ['SELECT a.b FROM t']
   end
 
+  specify "should raise if multiple arguments and can't determine alias" do
+    proc{@ds.select_map([:a.sql_function, :b])}.should raise_error(Sequel::Error)
+    proc{@ds.select_map(:a.sql_function){b}}.should raise_error(Sequel::Error)
+    proc{@ds.select_map{[a{}, b]}}.should raise_error(Sequel::Error)
+  end
+
   specify "should handle implicit aliases in arguments" do
     @ds.select_map(:a___b).should == [1, 2]
     @ds.db.sqls.should == ['SELECT a AS b FROM t']
@@ -3856,21 +3804,47 @@ describe "Sequel::Dataset#select_map" do
     @ds.db.sqls.should == ['SELECT a AS b FROM t']
   end
   
+  specify "should handle identifiers with strings" do
+    @ds.select_map([Sequel::SQL::Identifier.new('c'), :c]).should == [[1, 1], [2, 2]]
+    @ds.db.sqls.should == ['SELECT c, c FROM t']
+  end
+  
   specify "should accept a block" do
     @ds.select_map{a(t__c)}.should == [1, 2]
     @ds.db.sqls.should == ['SELECT a(t.c) FROM t']
   end
+
+  specify "should accept a block with an array of columns" do
+    @ds.select_map{[a(t__c).as(c), a(t__c).as(c)]}.should == [[1, 1], [2, 2]]
+    @ds.db.sqls.should == ['SELECT a(t.c) AS c, a(t.c) AS c FROM t']
+  end
+
+  specify "should accept a block with a column" do
+    @ds.select_map(:c){a(t__c).as(c)}.should == [[1, 1], [2, 2]]
+    @ds.db.sqls.should == ['SELECT c, a(t.c) AS c FROM t']
+  end
+
+  specify "should accept a block and array of arguments" do
+    @ds.select_map([:c, :c]){[a(t__c).as(c), a(t__c).as(c)]}.should == [[1, 1, 1, 1], [2, 2, 2, 2]]
+    @ds.db.sqls.should == ['SELECT c, c, a(t.c) AS c, a(t.c) AS c FROM t']
+  end
+
+  specify "should handle an array of columns" do
+    @ds.select_map([:c, :c]).should == [[1, 1], [2, 2]]
+    @ds.db.sqls.should == ['SELECT c, c FROM t']
+    @ds.select_map([:d.as(:c), :c.qualify(:b), :c.identifier, :c.identifier.qualify(:b), :a__c, :a__d___c]).should == [[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2]]
+    @ds.db.sqls.should == ['SELECT d AS c, b.c, c, b.c, a.c, a.d AS c FROM t']
+  end
+
+  specify "should handle an array with a single element" do
+    @ds.select_map([:c]).should == [[1], [2]]
+    @ds.db.sqls.should == ['SELECT c FROM t']
+  end
 end
 
 describe "Sequel::Dataset#select_order_map" do
   before do
-    @ds = MockDatabase.new[:t]
-    def @ds.fetch_rows(sql)
-      db << sql
-      yield({:c=>1})
-      yield({:c=>2})
-    end
-    @ds.db.reset
+    @ds = Sequel.mock(:fetch=>[{:c=>1}, {:c=>2}])[:t]
   end
 
   specify "should do select and map in one step" do
@@ -3883,6 +3857,12 @@ describe "Sequel::Dataset#select_order_map" do
     @ds.db.sqls.should == ['SELECT a.b FROM t ORDER BY a.b']
   end
 
+  specify "should raise if multiple arguments and can't determine alias" do
+    proc{@ds.select_order_map([:a.sql_function, :b])}.should raise_error(Sequel::Error)
+    proc{@ds.select_order_map(:a.sql_function){b}}.should raise_error(Sequel::Error)
+    proc{@ds.select_order_map{[a{}, b]}}.should raise_error(Sequel::Error)
+  end
+
   specify "should handle implicit aliases in arguments" do
     @ds.select_order_map(:a___b).should == [1, 2]
     @ds.db.sqls.should == ['SELECT a AS b FROM t ORDER BY a']
@@ -3898,55 +3878,104 @@ describe "Sequel::Dataset#select_order_map" do
     @ds.db.sqls.should == ['SELECT a AS b FROM t ORDER BY a']
   end
   
+  specify "should handle OrderedExpressions" do
+    @ds.select_order_map(:a.desc).should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a FROM t ORDER BY a DESC']
+  end
+  
   specify "should accept a block" do
     @ds.select_order_map{a(t__c)}.should == [1, 2]
     @ds.db.sqls.should == ['SELECT a(t.c) FROM t ORDER BY a(t.c)']
   end
+
+  specify "should accept a block with an array of columns" do
+    @ds.select_order_map{[c.desc, a(t__c).as(c)]}.should == [[1, 1], [2, 2]]
+    @ds.db.sqls.should == ['SELECT c, a(t.c) AS c FROM t ORDER BY c DESC, a(t.c)']
+  end
+
+  specify "should accept a block with a column" do
+    @ds.select_order_map(:c){a(t__c).as(c)}.should == [[1, 1], [2, 2]]
+    @ds.db.sqls.should == ['SELECT c, a(t.c) AS c FROM t ORDER BY c, a(t.c)']
+  end
+
+  specify "should accept a block and array of arguments" do
+    @ds.select_order_map([:c, :c]){[a(t__c).as(c), c.desc]}.should == [[1, 1, 1, 1], [2, 2, 2, 2]]
+    @ds.db.sqls.should == ['SELECT c, c, a(t.c) AS c, c FROM t ORDER BY c, c, a(t.c), c DESC']
+  end
+
+  specify "should handle an array of columns" do
+    @ds.select_order_map([:c, :c]).should == [[1, 1], [2, 2]]
+    @ds.db.sqls.should == ['SELECT c, c FROM t ORDER BY c, c']
+    @ds.select_order_map([:d.as(:c), :c.qualify(:b), :c.identifier, :c.identifier.qualify(:b), :c.identifier.qualify(:b).desc, :a__c, :a__d___c.desc]).should == [[1, 1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2, 2]]
+    @ds.db.sqls.should == ['SELECT d AS c, b.c, c, b.c, b.c, a.c, a.d AS c FROM t ORDER BY d, b.c, c, b.c, b.c DESC, a.c, a.d DESC']
+  end
+
+  specify "should handle an array with a single element" do
+    @ds.select_order_map([:c]).should == [[1], [2]]
+    @ds.db.sqls.should == ['SELECT c FROM t ORDER BY c']
+  end
 end
 
 describe "Sequel::Dataset#select_hash" do
   before do
-    @ds = MockDatabase.new[:t]
-    def @ds.set_fr_yield(hs)
-      @hs = hs
-    end
-    def @ds.fetch_rows(sql)
-      db << sql
-      @hs.each{|h| yield h}
-    end
-    @ds.db.reset
+    @db = Sequel.mock(:fetch=>[{:a=>1, :b=>2}, {:a=>3, :b=>4}])
+    @ds = @db[:t]
   end
 
-  specify "should do select and map in one step" do
-    @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
+  specify "should do select and to_hash in one step" do
     @ds.select_hash(:a, :b).should == {1=>2, 3=>4}
     @ds.db.sqls.should == ['SELECT a, b FROM t']
   end
 
   specify "should handle implicit qualifiers in arguments" do
-    @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
     @ds.select_hash(:t__a, :t__b).should == {1=>2, 3=>4}
     @ds.db.sqls.should == ['SELECT t.a, t.b FROM t']
   end
 
   specify "should handle implicit aliases in arguments" do
-    @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
     @ds.select_hash(:c___a, :d___b).should == {1=>2, 3=>4}
     @ds.db.sqls.should == ['SELECT c AS a, d AS b FROM t']
   end
 
   specify "should handle implicit qualifiers and aliases in arguments" do
-    @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
     @ds.select_hash(:t__c___a, :t__d___b).should == {1=>2, 3=>4}
     @ds.db.sqls.should == ['SELECT t.c AS a, t.d AS b FROM t']
   end
+
+  specify "should handle SQL::Identifiers in arguments" do
+    @ds.select_hash(:a.identifier, :b.identifier).should == {1=>2, 3=>4}
+    @ds.db.sqls.should == ['SELECT a, b FROM t']
+  end
+
+  specify "should handle SQL::QualifiedIdentifiers in arguments" do
+    @ds.select_hash(:a.qualify(:t), :b.identifier.qualify(:t)).should == {1=>2, 3=>4}
+    @ds.db.sqls.should == ['SELECT t.a, t.b FROM t']
+  end
+
+  specify "should handle SQL::AliasedExpressions in arguments" do
+    @ds.select_hash(:c.as(:a), :t.as(:b)).should == {1=>2, 3=>4}
+    @ds.db.sqls.should == ['SELECT c AS a, t AS b FROM t']
+  end
+
+  specify "should work with arrays of columns" do
+    @db.fetch = [{:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}]
+    @ds.select_hash([:a, :c], :b).should == {[1, 3]=>2, [4, 6]=>5}
+    @ds.db.sqls.should == ['SELECT a, c, b FROM t']
+    @ds.select_hash(:a, [:b, :c]).should == {1=>[2, 3], 4=>[5, 6]}
+    @ds.db.sqls.should == ['SELECT a, b, c FROM t']
+    @ds.select_hash([:a, :b], [:b, :c]).should == {[1, 2]=>[2, 3], [4, 5]=>[5, 6]}
+    @ds.db.sqls.should == ['SELECT a, b, b, c FROM t']
+  end
+
+  specify "should raise an error if the resulting symbol cannot be determined" do
+    proc{@ds.select_hash(:c.as(:a), :b.sql_function)}.should raise_error(Sequel::Error)
+  end
 end
 
 describe "Modifying joined datasets" do
   before do
-    @ds = MockDatabase.new.from(:b, :c).join(:d, [:id]).where(:id => 2)
+    @ds = Sequel.mock.from(:b, :c).join(:d, [:id]).where(:id => 2)
     @ds.meta_def(:supports_modifying_joins?){true}
-    @ds.db.reset
   end
 
   specify "should allow deleting from joined datasets" do
@@ -3962,7 +3991,7 @@ end
 
 describe "Dataset#lock_style and for_update" do
   before do
-    @ds = MockDatabase.new[:t]
+    @ds = Sequel::Dataset.new(nil).from(:t)
   end
   
   specify "#for_update should use FOR UPDATE" do
@@ -3977,3 +4006,89 @@ describe "Dataset#lock_style and for_update" do
     @ds.lock_style("FOR SHARE").sql.should == "SELECT * FROM t FOR SHARE"
   end
 end
+
+describe "Custom ASTTransformer" do
+  specify "should transform given objects" do
+    c = Class.new(Sequel::ASTTransformer) do
+      def v(s)
+        (s.is_a?(Symbol) || s.is_a?(String)) ? :"#{s}#{s}" : super
+      end
+    end.new
+    ds = Sequel::Dataset.new(nil).from(:t).cross_join(:a___g).join(:b___h, [:c]).join(:d___i, :e=>:f)
+    ds.sql.should == 'SELECT * FROM t CROSS JOIN a AS g INNER JOIN b AS h USING (c) INNER JOIN d AS i ON (i.e = h.f)'
+    ds.clone(:from=>c.transform(ds.opts[:from]), :join=>c.transform(ds.opts[:join])).sql.should == 'SELECT * FROM tt CROSS JOIN aa AS gg INNER JOIN bb AS hh USING (cc) INNER JOIN dd AS ii ON (ii.ee = hh.ff)'
+  end
+end
+
+describe "Dataset#returning" do
+  before do
+    @ds = Sequel.mock(:fetch=>proc{|s| {:foo=>s}})[:t].returning(:foo)
+    @pr = proc do
+      [:insert, :update, :delete].each do |m|
+        @ds.meta_def(:"#{m}_clause_methods"){super() + [:"#{m}_returning_sql"]}
+      end
+    end
+  end
+  
+  specify "should use RETURNING clause in the SQL if the dataset supports it" do
+    @pr.call
+    @ds.delete_sql.should == "DELETE FROM t RETURNING foo"
+    @ds.insert_sql(1).should == "INSERT INTO t VALUES (1) RETURNING foo"
+    @ds.update_sql(:foo=>1).should == "UPDATE t SET foo = 1 RETURNING foo"
+  end
+  
+  specify "should not use RETURNING clause in the SQL if the dataset does not support it" do
+    @ds.delete_sql.should == "DELETE FROM t"
+    @ds.insert_sql(1).should == "INSERT INTO t VALUES (1)"
+    @ds.update_sql(:foo=>1).should == "UPDATE t SET foo = 1"
+  end
+
+  specify "should have insert, update, and delete yield to blocks if RETURNING is used" do
+    @pr.call
+    h = {}
+    @ds.delete{|r| h = r}
+    h.should == {:foo=>"DELETE FROM t RETURNING foo"}
+    @ds.insert(1){|r| h = r}
+    h.should == {:foo=>"INSERT INTO t VALUES (1) RETURNING foo"}
+    @ds.update(:foo=>1){|r| h = r}
+    h.should == {:foo=>"UPDATE t SET foo = 1 RETURNING foo"}
+  end
+
+  specify "should have insert, update, and delete return arrays of hashes if RETURNING is used and a block is not given" do
+    @pr.call
+    h = {}
+    @ds.delete.should == [{:foo=>"DELETE FROM t RETURNING foo"}]
+    @ds.insert(1).should == [{:foo=>"INSERT INTO t VALUES (1) RETURNING foo"}]
+    @ds.update(:foo=>1).should == [{:foo=>"UPDATE t SET foo = 1 RETURNING foo"}]
+  end
+end
+
+describe "Dataset emulating bitwise operator support" do
+  before do
+    @ds = Sequel::Database.new.dataset
+    @ds.quote_identifiers = true
+    def @ds.complex_expression_sql_append(sql, op, args)
+      sql << complex_expression_arg_pairs(args){|a, b| "bitand(#{literal(a)}, #{literal(b)})"}
+    end
+  end
+
+  it "should work with any numbers of arguments for operators" do
+    @ds.select(Sequel::SQL::ComplexExpression.new(:&, :x)).sql.should == 'SELECT "x"'
+    @ds.select(:x & 1).sql.should == 'SELECT bitand("x", 1)'
+    @ds.select(:x & 1 & 2).sql.should == 'SELECT bitand(bitand("x", 1), 2)'
+  end
+end
+
+describe "Dataset feature defaults" do
+  it "should not require aliases for recursive CTEs by default" do
+    Sequel::Database.new.dataset.recursive_cte_requires_column_aliases?.should be_false
+  end
+
+  it "should not require placeholder type specifiers by default" do
+    Sequel::Database.new.dataset.requires_placeholder_type_specifiers?.should be_false
+  end
+
+  it "offset use should be returning a separate row number column by default" do
+    Sequel::Database.new.dataset.send(:offset_returns_row_number_column?).should be_false
+  end
+end