sequel 3.28.0 → 3.29.0

data/spec/integration/prepared_statement_test.rb

@@ -5,219 +5,220 @@ describe "Prepared Statements and Bound Arguments" do
     @db = INTEGRATION_DB
     @db.create_table!(:items) do
       primary_key :id
-      integer :number
+      integer :numb
     end
     @c = Class.new(Sequel::Model(:items))
     @ds = @db[:items]
-    @ds.insert(:number=>10)
+    @ds.insert(:numb=>10)
+    @pr = @ds.requires_placeholder_type_specifiers? ? proc{|i| :"#{i}__integer"} : proc{|i| i}
   end
   after do
     @db.drop_table(:items)
   end
   
   specify "should support bound variables with select, all, and first" do
-    @ds.filter(:number=>:$n).call(:select, :n=>10).should == [{:id=>1, :number=>10}]
-    @ds.filter(:number=>:$n).call(:all, :n=>10).should == [{:id=>1, :number=>10}]
-    @ds.filter(:number=>:$n).call(:first, :n=>10).should == {:id=>1, :number=>10}
+    @ds.filter(:numb=>:$n).call(:select, :n=>10).should == [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).call(:all, :n=>10).should == [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).call(:first, :n=>10).should == {:id=>1, :numb=>10}
   end
     
   specify "should support blocks for select and all" do
-    @ds.filter(:number=>:$n).call(:select, :n=>10){|r| r[:number] *= 2}.should == [{:id=>1, :number=>20}]
-    @ds.filter(:number=>:$n).call(:all, :n=>10){|r| r[:number] *= 2}.should == [{:id=>1, :number=>20}]
+    @ds.filter(:numb=>:$n).call(:select, :n=>10){|r| r[:numb] *= 2}.should == [{:id=>1, :numb=>20}]
+    @ds.filter(:numb=>:$n).call(:all, :n=>10){|r| r[:numb] *= 2}.should == [{:id=>1, :numb=>20}]
   end
     
   specify "should support binding variables before the call with #bind" do
-    @ds.filter(:number=>:$n).bind(:n=>10).call(:select).should == [{:id=>1, :number=>10}]
-    @ds.filter(:number=>:$n).bind(:n=>10).call(:all).should == [{:id=>1, :number=>10}]
-    @ds.filter(:number=>:$n).bind(:n=>10).call(:first).should == {:id=>1, :number=>10}
+    @ds.filter(:numb=>:$n).bind(:n=>10).call(:select).should == [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>10).call(:all).should == [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>10).call(:first).should == {:id=>1, :numb=>10}
     
-    @ds.bind(:n=>10).filter(:number=>:$n).call(:select).should == [{:id=>1, :number=>10}]
-    @ds.bind(:n=>10).filter(:number=>:$n).call(:all).should == [{:id=>1, :number=>10}]
-    @ds.bind(:n=>10).filter(:number=>:$n).call(:first).should == {:id=>1, :number=>10}
+    @ds.bind(:n=>10).filter(:numb=>:$n).call(:select).should == [{:id=>1, :numb=>10}]
+    @ds.bind(:n=>10).filter(:numb=>:$n).call(:all).should == [{:id=>1, :numb=>10}]
+    @ds.bind(:n=>10).filter(:numb=>:$n).call(:first).should == {:id=>1, :numb=>10}
   end
   
   specify "should allow overriding variables specified with #bind" do
-    @ds.filter(:number=>:$n).bind(:n=>1).call(:select, :n=>10).should == [{:id=>1, :number=>10}]
-    @ds.filter(:number=>:$n).bind(:n=>1).call(:all, :n=>10).should == [{:id=>1, :number=>10}]
-    @ds.filter(:number=>:$n).bind(:n=>1).call(:first, :n=>10).should == {:id=>1, :number=>10}
+    @ds.filter(:numb=>:$n).bind(:n=>1).call(:select, :n=>10).should == [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>1).call(:all, :n=>10).should == [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>1).call(:first, :n=>10).should == {:id=>1, :numb=>10}
     
-    @ds.filter(:number=>:$n).bind(:n=>1).bind(:n=>10).call(:select).should == [{:id=>1, :number=>10}]
-    @ds.filter(:number=>:$n).bind(:n=>1).bind(:n=>10).call(:all).should == [{:id=>1, :number=>10}]
-    @ds.filter(:number=>:$n).bind(:n=>1).bind(:n=>10).call(:first).should == {:id=>1, :number=>10}
+    @ds.filter(:numb=>:$n).bind(:n=>1).bind(:n=>10).call(:select).should == [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>1).bind(:n=>10).call(:all).should == [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>1).bind(:n=>10).call(:first).should == {:id=>1, :numb=>10}
   end
 
   specify "should support placeholder literal strings with call" do
-    @ds.filter("number = ?", :$n).call(:select, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter("numb = ?", :$n).call(:select, :n=>10).should == [{:id=>1, :numb=>10}]
   end
 
   specify "should support named placeholder literal strings and handle multiple named placeholders correctly with call" do
-    @ds.filter("number = :n", :n=>:$n).call(:select, :n=>10).should == [{:id=>1, :number=>10}]
-    @ds.insert(:number=>20)
-    @ds.insert(:number=>30)
-    @ds.filter("number > :n1 AND number < :n2 AND number = :n3", :n3=>:$n3, :n2=>:$n2, :n1=>:$n1).call(:select, :n3=>20, :n2=>30, :n1=>10).should == [{:id=>2, :number=>20}]
+    @ds.filter("numb = :n", :n=>:$n).call(:select, :n=>10).should == [{:id=>1, :numb=>10}]
+    @ds.insert(:numb=>20)
+    @ds.insert(:numb=>30)
+    @ds.filter("numb > :n1 AND numb < :n2 AND numb = :n3", :n3=>:$n3, :n2=>:$n2, :n1=>:$n1).call(:select, :n3=>20, :n2=>30, :n1=>10).should == [{:id=>2, :numb=>20}]
   end
 
   specify "should support datasets with static sql and placeholders with call" do
-    @db["SELECT * FROM items WHERE number = ?", :$n].call(:select, :n=>10).should == [{:id=>1, :number=>10}]
+    @db["SELECT * FROM items WHERE numb = ?", :$n].call(:select, :n=>10).should == [{:id=>1, :numb=>10}]
   end
 
   specify "should support subselects with call" do
-    @ds.filter(:id=>:$i).filter(:number=>@ds.select(:number).filter(:number=>:$n)).filter(:id=>:$j).call(:select, :n=>10, :i=>1, :j=>1).should == [{:id=>1, :number=>10}]
+    @ds.filter(:id=>:$i).filter(:numb=>@ds.select(:numb).filter(:numb=>:$n)).filter(:id=>:$j).call(:select, :n=>10, :i=>1, :j=>1).should == [{:id=>1, :numb=>10}]
   end
 
   specify "should support subselects with literal strings with call" do
-    @ds.filter(:id=>:$i, :number=>@ds.select(:number).filter("number = ?", :$n)).call(:select, :n=>10, :i=>1).should == [{:id=>1, :number=>10}]
+    @ds.filter(:id=>:$i, :numb=>@ds.select(:numb).filter("numb = ?", :$n)).call(:select, :n=>10, :i=>1).should == [{:id=>1, :numb=>10}]
   end
 
   specify "should support subselects with static sql and placeholders with call" do
-    @ds.filter(:id=>:$i, :number=>@db["SELECT number FROM items WHERE number = ?", :$n]).call(:select, :n=>10, :i=>1).should == [{:id=>1, :number=>10}]
+    @ds.filter(:id=>:$i, :numb=>@db["SELECT numb FROM items WHERE numb = ?", :$n]).call(:select, :n=>10, :i=>1).should == [{:id=>1, :numb=>10}]
   end
 
   specify "should support subselects of subselects with call" do
-    @ds.filter(:id=>:$i).filter(:number=>@ds.select(:number).filter(:number=>@ds.select(:number).filter(:number=>:$n))).filter(:id=>:$j).call(:select, :n=>10, :i=>1, :j=>1).should == [{:id=>1, :number=>10}]
+    @ds.filter(:id=>:$i).filter(:numb=>@ds.select(:numb).filter(:numb=>@ds.select(:numb).filter(:numb=>:$n))).filter(:id=>:$j).call(:select, :n=>10, :i=>1, :j=>1).should == [{:id=>1, :numb=>10}]
   end
   
   cspecify "should support using a bound variable for a limit and offset", [:jdbc, :db2] do
-    @ds.insert(:number=>20)
+    @ds.insert(:numb=>20)
     ds = @ds.limit(:$n, :$n2).order(:id)
-    ds.call(:select, :n=>1, :n2=>0).should == [{:id=>1, :number=>10}]
-    ds.call(:select, :n=>1, :n2=>1).should == [{:id=>2, :number=>20}]
+    ds.call(:select, :n=>1, :n2=>0).should == [{:id=>1, :numb=>10}]
+    ds.call(:select, :n=>1, :n2=>1).should == [{:id=>2, :numb=>20}]
     ds.call(:select, :n=>1, :n2=>2).should == []
-    ds.call(:select, :n=>2, :n2=>0).should == [{:id=>1, :number=>10}, {:id=>2, :number=>20}]
-    ds.call(:select, :n=>2, :n2=>1).should == [{:id=>2, :number=>20}]
+    ds.call(:select, :n=>2, :n2=>0).should == [{:id=>1, :numb=>10}, {:id=>2, :numb=>20}]
+    ds.call(:select, :n=>2, :n2=>1).should == [{:id=>2, :numb=>20}]
   end
 
   specify "should support bound variables with insert" do
-    @ds.call(:insert, {:n=>20}, :number=>:$n)
+    @ds.call(:insert, {:n=>20}, :numb=>:$n)
     @ds.count.should == 2
-    @ds.order(:id).map(:number).should == [10, 20]
+    @ds.order(:id).map(:numb).should == [10, 20]
   end
 
   specify "should support bound variables with NULL values" do
     @ds.delete
-    @ds.call(:insert, {:n=>nil}, :number=>:$n)
+    @ds.call(:insert, {:n=>nil}, :numb=>@pr[:$n])
     @ds.count.should == 1
-    @ds.map(:number).should == [nil]
+    @ds.map(:numb).should == [nil]
   end
 
   specify "should have insert return primary key value when using bound arguments" do
-    @ds.call(:insert, {:n=>20}, :number=>:$n).should == 2
-    @ds.filter(:id=>2).first[:number].should == 20
+    @ds.call(:insert, {:n=>20}, :numb=>:$n).should == 2
+    @ds.filter(:id=>2).first[:numb].should == 20
   end
 
   specify "should support bound variables with delete" do
-    @ds.filter(:number=>:$n).call(:delete, :n=>10).should == 1
+    @ds.filter(:numb=>:$n).call(:delete, :n=>10).should == 1
     @ds.count.should == 0
   end
 
   specify "should support bound variables with update" do
-    @ds.filter(:number=>:$n).call(:update, {:n=>10, :nn=>20}, :number=>:number+:$nn).should == 1
-    @ds.all.should == [{:id=>1, :number=>30}]
+    @ds.filter(:numb=>:$n).call(:update, {:n=>10, :nn=>20}, :numb=>:numb+:$nn).should == 1
+    @ds.all.should == [{:id=>1, :numb=>30}]
   end
   
   specify "should support prepared statements with select, first, and all" do
-    @ds.filter(:number=>:$n).prepare(:select, :select_n)
-    @db.call(:select_n, :n=>10).should == [{:id=>1, :number=>10}]
-    @ds.filter(:number=>:$n).prepare(:all, :select_n)
-    @db.call(:select_n, :n=>10).should == [{:id=>1, :number=>10}]
-    @ds.filter(:number=>:$n).prepare(:first, :select_n)
-    @db.call(:select_n, :n=>10).should == {:id=>1, :number=>10}
+    @ds.filter(:numb=>:$n).prepare(:select, :select_n)
+    @db.call(:select_n, :n=>10).should == [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).prepare(:all, :select_n)
+    @db.call(:select_n, :n=>10).should == [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).prepare(:first, :select_n)
+    @db.call(:select_n, :n=>10).should == {:id=>1, :numb=>10}
   end
 
   specify "should support prepared statements being call multiple times with different arguments" do
-    @ds.filter(:number=>:$n).prepare(:select, :select_n)
-    @db.call(:select_n, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter(:numb=>:$n).prepare(:select, :select_n)
+    @db.call(:select_n, :n=>10).should == [{:id=>1, :numb=>10}]
     @db.call(:select_n, :n=>0).should == []
-    @db.call(:select_n, :n=>10).should == [{:id=>1, :number=>10}]
+    @db.call(:select_n, :n=>10).should == [{:id=>1, :numb=>10}]
   end
 
   specify "should support placeholder literal strings with prepare" do
-    @ds.filter("number = ?", :$n).prepare(:select, :seq_select).call(:n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter("numb = ?", :$n).prepare(:select, :seq_select).call(:n=>10).should == [{:id=>1, :numb=>10}]
   end
 
   specify "should support named placeholder literal strings and handle multiple named placeholders correctly with prepare" do
-    @ds.filter("number = :n", :n=>:$n).prepare(:select, :seq_select).call(:n=>10).should == [{:id=>1, :number=>10}]
-    @ds.insert(:number=>20)
-    @ds.insert(:number=>30)
-    @ds.filter("number > :n1 AND number < :n2 AND number = :n3", :n3=>:$n3, :n2=>:$n2, :n1=>:$n1).call(:select, :n3=>20, :n2=>30, :n1=>10).should == [{:id=>2, :number=>20}]
+    @ds.filter("numb = :n", :n=>:$n).prepare(:select, :seq_select).call(:n=>10).should == [{:id=>1, :numb=>10}]
+    @ds.insert(:numb=>20)
+    @ds.insert(:numb=>30)
+    @ds.filter("numb > :n1 AND numb < :n2 AND numb = :n3", :n3=>:$n3, :n2=>:$n2, :n1=>:$n1).call(:select, :n3=>20, :n2=>30, :n1=>10).should == [{:id=>2, :numb=>20}]
   end
 
   specify "should support datasets with static sql and placeholders with prepare" do
-    @db["SELECT * FROM items WHERE number = ?", :$n].prepare(:select, :seq_select).call(:n=>10).should == [{:id=>1, :number=>10}]
+    @db["SELECT * FROM items WHERE numb = ?", :$n].prepare(:select, :seq_select).call(:n=>10).should == [{:id=>1, :numb=>10}]
   end
 
   specify "should support subselects with prepare" do
-    @ds.filter(:id=>:$i).filter(:number=>@ds.select(:number).filter(:number=>:$n)).filter(:id=>:$j).prepare(:select, :seq_select).call(:n=>10, :i=>1, :j=>1).should == [{:id=>1, :number=>10}]
+    @ds.filter(:id=>:$i).filter(:numb=>@ds.select(:numb).filter(:numb=>:$n)).filter(:id=>:$j).prepare(:select, :seq_select).call(:n=>10, :i=>1, :j=>1).should == [{:id=>1, :numb=>10}]
   end
 
   specify "should support subselects with literal strings with prepare" do
-    @ds.filter(:id=>:$i, :number=>@ds.select(:number).filter("number = ?", :$n)).prepare(:select, :seq_select).call(:n=>10, :i=>1).should == [{:id=>1, :number=>10}]
+    @ds.filter(:id=>:$i, :numb=>@ds.select(:numb).filter("numb = ?", :$n)).prepare(:select, :seq_select).call(:n=>10, :i=>1).should == [{:id=>1, :numb=>10}]
   end
 
   specify "should support subselects with static sql and placeholders with prepare" do
-    @ds.filter(:id=>:$i, :number=>@db["SELECT number FROM items WHERE number = ?", :$n]).prepare(:select, :seq_select).call(:n=>10, :i=>1).should == [{:id=>1, :number=>10}]
+    @ds.filter(:id=>:$i, :numb=>@db["SELECT numb FROM items WHERE numb = ?", :$n]).prepare(:select, :seq_select).call(:n=>10, :i=>1).should == [{:id=>1, :numb=>10}]
   end
 
   specify "should support subselects of subselects with prepare" do
-    @ds.filter(:id=>:$i).filter(:number=>@ds.select(:number).filter(:number=>@ds.select(:number).filter(:number=>:$n))).filter(:id=>:$j).prepare(:select, :seq_select).call(:n=>10, :i=>1, :j=>1).should == [{:id=>1, :number=>10}]
+    @ds.filter(:id=>:$i).filter(:numb=>@ds.select(:numb).filter(:numb=>@ds.select(:numb).filter(:numb=>:$n))).filter(:id=>:$j).prepare(:select, :seq_select).call(:n=>10, :i=>1, :j=>1).should == [{:id=>1, :numb=>10}]
   end
   
   cspecify "should support using a prepared_statement for a limit and offset", :db2 do
-    @ds.insert(:number=>20)
+    @ds.insert(:numb=>20)
     ps = @ds.limit(:$n, :$n2).order(:id).prepare(:select, :seq_select)
-    ps.call(:n=>1, :n2=>0).should == [{:id=>1, :number=>10}]
-    ps.call(:n=>1, :n2=>1).should == [{:id=>2, :number=>20}]
+    ps.call(:n=>1, :n2=>0).should == [{:id=>1, :numb=>10}]
+    ps.call(:n=>1, :n2=>1).should == [{:id=>2, :numb=>20}]
     ps.call(:n=>1, :n2=>2).should == []
-    ps.call(:n=>2, :n2=>0).should == [{:id=>1, :number=>10}, {:id=>2, :number=>20}]
-    ps.call(:n=>2, :n2=>1).should == [{:id=>2, :number=>20}]
+    ps.call(:n=>2, :n2=>0).should == [{:id=>1, :numb=>10}, {:id=>2, :numb=>20}]
+    ps.call(:n=>2, :n2=>1).should == [{:id=>2, :numb=>20}]
   end
 
   specify "should support prepared statements with insert" do
-    @ds.prepare(:insert, :insert_n, :number=>:$n)
+    @ds.prepare(:insert, :insert_n, :numb=>:$n)
     @db.call(:insert_n, :n=>20)
     @ds.count.should == 2
-    @ds.order(:id).map(:number).should == [10, 20]
+    @ds.order(:id).map(:numb).should == [10, 20]
   end
 
   specify "should support prepared statements with NULL values" do
     @ds.delete
-    @ds.prepare(:insert, :insert_n, :number=>:$n)
+    @ds.prepare(:insert, :insert_n, :numb=>@pr[:$n])
     @db.call(:insert_n, :n=>nil)
     @ds.count.should == 1
-    @ds.map(:number).should == [nil]
+    @ds.map(:numb).should == [nil]
   end
 
   specify "should have insert return primary key value when using prepared statements" do
-    @ds.prepare(:insert, :insert_n, :number=>:$n)
+    @ds.prepare(:insert, :insert_n, :numb=>:$n)
     @db.call(:insert_n, :n=>20).should == 2
-    @ds.filter(:id=>2).first[:number].should == 20
+    @ds.filter(:id=>2).first[:numb].should == 20
   end
 
   specify "should support prepared statements with delete" do
-    @ds.filter(:number=>:$n).prepare(:delete, :delete_n)
+    @ds.filter(:numb=>:$n).prepare(:delete, :delete_n)
     @db.call(:delete_n, :n=>10).should == 1
     @ds.count.should == 0
   end
 
   specify "should support prepared statements with update" do
-    @ds.filter(:number=>:$n).prepare(:update, :update_n, :number=>:number+:$nn)
+    @ds.filter(:numb=>:$n).prepare(:update, :update_n, :numb=>:numb+:$nn)
     @db.call(:update_n, :n=>10, :nn=>20).should == 1
-    @ds.all.should == [{:id=>1, :number=>30}]
+    @ds.all.should == [{:id=>1, :numb=>30}]
   end
   
   specify "model datasets should return model instances when using select, all, and first with bound variables" do
-    @c.filter(:number=>:$n).call(:select, :n=>10).should == [@c.load(:id=>1, :number=>10)]
-    @c.filter(:number=>:$n).call(:all, :n=>10).should == [@c.load(:id=>1, :number=>10)]
-    @c.filter(:number=>:$n).call(:first, :n=>10).should == @c.load(:id=>1, :number=>10)
+    @c.filter(:numb=>:$n).call(:select, :n=>10).should == [@c.load(:id=>1, :numb=>10)]
+    @c.filter(:numb=>:$n).call(:all, :n=>10).should == [@c.load(:id=>1, :numb=>10)]
+    @c.filter(:numb=>:$n).call(:first, :n=>10).should == @c.load(:id=>1, :numb=>10)
   end
   
   specify "model datasets should return model instances when using select, all, and first with prepared statements" do
-    @c.filter(:number=>:$n).prepare(:select, :select_n)
-    @db.call(:select_n, :n=>10).should == [@c.load(:id=>1, :number=>10)]
-    @c.filter(:number=>:$n).prepare(:all, :select_n)
-    @db.call(:select_n, :n=>10).should == [@c.load(:id=>1, :number=>10)]
-    @c.filter(:number=>:$n).prepare(:first, :select_n)
-    @db.call(:select_n, :n=>10).should == @c.load(:id=>1, :number=>10)
+    @c.filter(:numb=>:$n).prepare(:select, :select_n1)
+    @db.call(:select_n1, :n=>10).should == [@c.load(:id=>1, :numb=>10)]
+    @c.filter(:numb=>:$n).prepare(:all, :select_n1)
+    @db.call(:select_n1, :n=>10).should == [@c.load(:id=>1, :numb=>10)]
+    @c.filter(:numb=>:$n).prepare(:first, :select_n1)
+    @db.call(:select_n1, :n=>10).should == @c.load(:id=>1, :numb=>10)
   end
 end
 
@@ -246,11 +247,11 @@ describe "Bound Argument Types" do
     @db.drop_table(:items)
   end
 
-  cspecify "should handle date type", [:do, :sqlite], :mssql, [:jdbc, :sqlite] do 
+  cspecify "should handle date type", [:do, :sqlite], :mssql, [:jdbc, :sqlite], :oracle do 
     @ds.filter(:d=>:$x).prepare(:first, :ps_date).call(:x=>@vs[:d])[:d].should == @vs[:d]
   end
 
-  cspecify "should handle datetime type", [:do], [:mysql2], [:swift], [:jdbc, :sqlite], [:tinytds] do
+  cspecify "should handle datetime type", [:do], [:mysql2], [:swift], [:jdbc, :sqlite], [:tinytds], [:oracle] do
     Sequel.datetime_class = DateTime
     @ds.filter(:dt=>:$x).prepare(:first, :ps_datetime).call(:x=>@vs[:dt])[:dt].should == @vs[:dt]
   end
@@ -259,7 +260,7 @@ describe "Bound Argument Types" do
     @ds.filter(:t=>:$x).prepare(:first, :ps_time).call(:x=>@vs[:t])[:t].should == @vs[:t]
   end
 
-  cspecify "should handle blob type", [:swift], [:odbc], [:jdbc, :db2] do
+  cspecify "should handle blob type", [:swift], [:odbc], [:jdbc, :db2], :oracle, :derby do
     @ds.filter(:file=>:$x).prepare(:first, :ps_blob).call(:x=>@vs[:file])[:file].should == @vs[:file]
   end
 
@@ -271,10 +272,10 @@ describe "Bound Argument Types" do
     @ds.filter(:s=>:$x).prepare(:first, :ps_string).call(:x=>@vs[:s])[:s].should == @vs[:s]
   end
 
-  cspecify "should handle boolean type", [:do, :sqlite], [:odbc, :mssql], [:jdbc, :sqlite], [:jdbc, :db2]  do
+  cspecify "should handle boolean type", [:do, :sqlite], [:odbc, :mssql], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     @ds.filter(:b=>:$x).prepare(:first, :ps_string).call(:x=>@vs[:b])[:b].should == @vs[:b]
   end
-end unless INTEGRATION_DB.adapter_scheme == :swift && INTEGRATION_DB.database_type == :postgres
+end unless Sequel.guarded?([:swift, :postgres])
 
 describe "Dataset#unbind" do
   before do
@@ -316,7 +317,7 @@ describe "Dataset#unbind" do
     @u[@ds.filter{c > 0}].should == {:c=>BigDecimal.new('1.1')}
   end
 
-  cspecify "should handle dates and times", [:sqlite], [:do], [:jdbc, :mssql], [:tinytds] do
+  cspecify "should handle dates and times", [:do], [:jdbc, :mssql], [:jdbc, :sqlite], [:tinytds], :oracle do
     @ct[Date, Date.today]
     @u[@ds.filter(:c=>Date.today)].should == {:c=>Date.today}
     t = Time.now

data/spec/integration/schema_test.rb

@@ -7,7 +7,6 @@ describe "Database schema parser" do
     @iim = INTEGRATION_DB.identifier_input_method
     @defsch = INTEGRATION_DB.default_schema
     @qi = INTEGRATION_DB.quote_identifiers?
-    clear_sqls
   end
   after do
     INTEGRATION_DB.identifier_output_method = @iom
@@ -17,22 +16,45 @@ describe "Database schema parser" do
     INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
   end
 
-  specify "should handle a database with a identifier_output_method" do
+  specify "should handle a database with a identifier methods" do
     INTEGRATION_DB.identifier_output_method = :reverse
     INTEGRATION_DB.identifier_input_method = :reverse
     INTEGRATION_DB.quote_identifiers = true
     INTEGRATION_DB.default_schema = nil if INTEGRATION_DB.default_schema
     INTEGRATION_DB.create_table!(:items){Integer :number}
-    INTEGRATION_DB.schema(:items, :reload=>true).should be_a_kind_of(Array)
-    INTEGRATION_DB.schema(:items, :reload=>true).first.first.should == :number
+    begin
+      INTEGRATION_DB.schema(:items, :reload=>true).should be_a_kind_of(Array)
+      INTEGRATION_DB.schema(:items, :reload=>true).first.first.should == :number
+    ensure 
+      INTEGRATION_DB.drop_table(:items)
+    end
+  end
+
+  specify "should handle a dataset with identifier methods different than the database's" do
+    INTEGRATION_DB.identifier_output_method = :reverse
+    INTEGRATION_DB.identifier_input_method = :reverse
+    INTEGRATION_DB.quote_identifiers = true
+    INTEGRATION_DB.default_schema = nil if INTEGRATION_DB.default_schema
+    INTEGRATION_DB.create_table!(:items){Integer :number}
+    INTEGRATION_DB.identifier_output_method = @iom
+    INTEGRATION_DB.identifier_input_method = @iim
+    ds = INTEGRATION_DB[:items]
+    ds.identifier_output_method = :reverse
+    ds.identifier_input_method = :reverse
+    begin
+      INTEGRATION_DB.schema(ds, :reload=>true).should be_a_kind_of(Array)
+      INTEGRATION_DB.schema(ds, :reload=>true).first.first.should == :number
+    ensure 
+      INTEGRATION_DB.identifier_output_method = :reverse
+      INTEGRATION_DB.identifier_input_method = :reverse
+      INTEGRATION_DB.drop_table(:items)
+    end
   end
 
   specify "should not issue an sql query if the schema has been loaded unless :reload is true" do
     INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items, :reload=>true)
-    clear_sqls
     INTEGRATION_DB.schema(:items)
-    clear_sqls
     INTEGRATION_DB.schema(:items, :reload=>true)
   end
 
@@ -59,11 +81,10 @@ describe "Database schema parser" do
     col_info = col.last
     col_info.should be_a_kind_of(Hash)
     col_info[:type].should == :integer
-    clear_sqls
     INTEGRATION_DB.schema(:items)
   end
 
-  cspecify "should parse primary keys from the schema properly", [proc{|db| db.adapter_scheme != :jdbc}, :mssql] do
+  specify "should parse primary keys from the schema properly" do
     INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
     INTEGRATION_DB.create_table!(:items){primary_key :number}
@@ -88,7 +109,7 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == 'blah'
   end
 
-  cspecify "should parse types from the schema properly", [:jdbc, :db2] do
+  cspecify "should parse types from the schema properly", [:jdbc, :db2], :oracle do
     INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items).first.last[:type].should == :integer
     INTEGRATION_DB.create_table!(:items){Fixnum :number}
@@ -159,7 +180,6 @@ describe "Database schema modifiers" do
   before do
     @db = INTEGRATION_DB
     @ds = @db[:items]
-    clear_sqls
   end
   after do
     @db.drop_table(:items) if @db.table_exists?(:items)
@@ -242,7 +262,7 @@ describe "Database schema modifiers" do
     @ds.all.should == [{:number=>10, :name=>nil}]
   end
 
-  cspecify "should add primary key columns to tables correctly", :h2 do
+  cspecify "should add primary key columns to tables correctly", :h2, :derby do
     @db.create_table!(:items){Integer :number}
     @ds.insert(:number=>10)
     @db.alter_table(:items){add_primary_key :id}
@@ -252,7 +272,7 @@ describe "Database schema modifiers" do
     proc{@ds.insert(:id=>@ds.map(:id).first)}.should raise_error
   end
 
-  cspecify "should drop primary key constraints from tables correctly", :sqlite do
+  specify "should drop primary key constraints from tables correctly" do
     @db.create_table!(:items){Integer :number; primary_key [:number], :name=>:items_pk}
     @ds.insert(:number=>10)
     @db.alter_table(:items){drop_constraint :items_pk, :type=>:primary_key}
@@ -262,7 +282,8 @@ describe "Database schema modifiers" do
 
   specify "should add foreign key columns to tables correctly" do
     @db.create_table!(:items){primary_key :id}
-    i = @ds.insert
+    @ds.insert
+    i = @ds.get(:id)
     @db.alter_table(:items){add_foreign_key :item_id, :items}
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
     @ds.columns!.should == [:id, :item_id]
@@ -299,7 +320,7 @@ describe "Database schema modifiers" do
     proc{@ds.insert(:n=>nil)}.should raise_error(Sequel::DatabaseError)
   end
 
-  cspecify "should set column NULL/NOT NULL correctly", [:jdbc, :db2] do
+  cspecify "should set column NULL/NOT NULL correctly", [:jdbc, :db2], [:db2] do
     @db.create_table!(:items, :engine=>:InnoDB){Integer :id}
     @ds.insert(:id=>10)
     @db.alter_table(:items){set_column_allow_null :id, false}
@@ -307,7 +328,7 @@ describe "Database schema modifiers" do
     @ds.columns!.should == [:id]
     proc{@ds.insert(:id=>nil)}.should raise_error(Sequel::DatabaseError)
     @db.alter_table(:items){set_column_allow_null :id, true}
-    @ds.insert
+    @ds.insert(:id=>nil)
     @ds.all.should == [{:id=>10}, {:id=>nil}]
   end
 
@@ -321,17 +342,17 @@ describe "Database schema modifiers" do
     @ds.all.should == [{:id=>10}, {:id=>20}]
   end
 
-  cspecify "should set column types correctly", [:jdbc, :db2] do
+  cspecify "should set column types correctly", [:jdbc, :db2], [:db2], :oracle do
     @db.create_table!(:items){Integer :id}
     @ds.insert(:id=>10)
     @db.alter_table(:items){set_column_type :id, String}
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
     @ds.columns!.should == [:id]
-    @ds.insert(:id=>20)
+    @ds.insert(:id=>'20')
     @ds.all.should == [{:id=>"10"}, {:id=>"20"}]
   end
 
-  cspecify "should add unnamed unique constraints and foreign key table constraints correctly", :sqlite do
+  specify "should add unnamed unique constraints and foreign key table constraints correctly" do
     @db.create_table!(:items, :engine=>:InnoDB){Integer :id; Integer :item_id}
     @db.alter_table(:items) do
       add_unique_constraint [:item_id, :id]
@@ -344,7 +365,7 @@ describe "Database schema modifiers" do
     proc{@ds.insert(1, 2)}.should raise_error
   end
 
-  cspecify "should add named unique constraints and foreign key table constraints correctly", :sqlite do
+  specify "should add named unique constraints and foreign key table constraints correctly" do
     @db.create_table!(:items, :engine=>:InnoDB){Integer :id, :null=>false; Integer :item_id, :null=>false}
     @db.alter_table(:items) do
       add_unique_constraint [:item_id, :id], :name=>:unique_iii
@@ -357,7 +378,7 @@ describe "Database schema modifiers" do
     proc{@ds.insert(1, 2)}.should raise_error
   end
 
-  cspecify "should drop unique constraints and foreign key table constraints correctly", :sqlite do
+  specify "should drop unique constraints and foreign key table constraints correctly" do
     @db.create_table!(:items) do
       Integer :id
       Integer :item_id
@@ -374,7 +395,7 @@ describe "Database schema modifiers" do
     proc{@ds.insert(1, 2)}.should_not raise_error
   end
 
-  cspecify "should remove columns from tables correctly", :h2, :mssql, [:jdbc, :db2] do
+  cspecify "should remove columns from tables correctly", :h2, :mssql, [:jdbc, :db2], :hsqldb do
     @db.create_table!(:items) do
       primary_key :id
       String :name
@@ -430,7 +451,6 @@ describe "Database#tables" do
     @db.create_view :sequel_test_view, @db[:sequel_test_table]
     @iom = @db.identifier_output_method
     @iim = @db.identifier_input_method
-    clear_sqls
   end
   after do
     @db.identifier_output_method = @iom
@@ -472,7 +492,6 @@ describe "Database#views" do
     @db.create_view :sequel_test_view, @db[:sequel_test_table]
     @iom = @db.identifier_output_method
     @iim = @db.identifier_input_method
-    clear_sqls
   end
   after do
     @db.identifier_output_method = @iom