sequel 3.21.0 → 3.29.0

data/spec/integration/dataset_test.rb

@@ -2,16 +2,16 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "Simple Dataset operations" do
   before do
-    INTEGRATION_DB.create_table!(:items) do
+    @db = INTEGRATION_DB
+    @db.create_table!(:items) do
       primary_key :id
       Integer :number
     end
-    @ds = INTEGRATION_DB[:items]
+    @ds = @db[:items]
     @ds.insert(:number=>10)
-    clear_sqls
   end
   after do
-    INTEGRATION_DB.drop_table(:items)
+    @db.drop_table(:items)
   end
 
   specify "should support sequential primary keys" do
@@ -23,7 +23,7 @@ describe "Simple Dataset operations" do
       {:id => 3, :number=>30} ]   
   end 
 
-  cspecify "should insert with a primary key specified", :mssql do
+  cspecify "should insert with a primary key specified", :db2, :mssql do
     @ds.insert(:id=>100, :number=>20)
     @ds.count.should == 2
     @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
@@ -34,6 +34,37 @@ describe "Simple Dataset operations" do
     @ds.filter(:id=>2).first[:number].should == 20
   end
 
+  specify "should have insert work correctly with static SQL" do
+    @db["INSERT INTO #{@ds.literal(:items)} (#{@ds.literal(:number)}) VALUES (20)"].insert
+    @ds.filter(:id=>2).first[:number].should == 20
+  end
+
+  specify "should join correctly" do
+    @ds.join(:items___b, :id=>:id).select_all(:items).all.should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should correctly deal with qualified columns and subselects" do
+    @ds.from_self(:alias=>:a).select(:a__id, :number.qualify(:a)).all.should == [{:id=>1, :number=>10}]
+    @ds.join(@ds.as(:a), :id=>:id).select(:a__id, :number.qualify(:a)).all.should == [{:id=>1, :number=>10}]
+  end
+
+  specify "should graph correctly" do
+    @ds.graph(:items, {:id=>:id}, :table_alias=>:b).all.should == [{:items=>{:id=>1, :number=>10}, :b=>{:id=>1, :number=>10}}]
+  end
+
+  specify "should graph correctly with a subselect" do
+    @ds.from_self(:alias=>:items).graph(@ds.from_self, {:id=>:id}, :table_alias=>:b).all.should == [{:items=>{:id=>1, :number=>10}, :b=>{:id=>1, :number=>10}}]
+  end
+
+  cspecify "should have insert work correctly when inserting a row with all NULL values", :hsqldb do
+    @db.create_table!(:items) do
+      String :name
+      Integer :number
+    end
+    proc{@ds.insert}.should_not raise_error
+    @ds.all.should == [{:name=>nil, :number=>nil}]
+  end
+
   specify "should delete correctly" do
     @ds.filter(1=>1).delete.should == 1
     @ds.count.should == 0
@@ -79,13 +110,60 @@ describe "Simple Dataset operations" do
     @ds.order(:id).limit(2, 1).all.should == [{:id=>2, :number=>20}]
   end
   
-  cspecify "should fetch correctly with a limit and offset without an order", :mssql do
+  specify "should provide correct columns when using a limit and offset" do
+    ds = @ds.order(:id).limit(1, 1)
+    ds.all
+    ds.columns.should == [:id, :number]
+    @ds.order(:id).limit(1, 1).columns.should == [:id, :number]
+  end
+
+  specify "should fetch correctly with a limit and offset for different combinations of from and join tables" do
+    @db.create_table!(:items2){primary_key :id2; Integer :number2}
+    @db[:items2].insert(:number2=>10)
+    @ds.from(:items, :items2).order(:id).limit(2, 0).all.should == [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
+    @ds.from(:items___i, :items2___i2).order(:id).limit(2, 0).all.should == [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
+    @ds.cross_join(:items2).order(:id).limit(2, 0).all.should ==[{:id=>1, :number=>10, :id2=>1, :number2=>10}]
+    @ds.from(:items___i).cross_join(:items2___i2).order(:id).limit(2, 0).all.should == [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
+    @ds.cross_join(:items2___i).cross_join(@db[:items2].select(:id2___id3, :number2___number3)).order(:id).limit(2, 0).all.should == [{:id=>1, :number=>10, :id2=>1, :number2=>10, :id3=>1, :number3=>10}]
+
+    @ds.from(:items, :items2).order(:id).limit(2, 1).all.should == []
+    @ds.from(:items___i, :items2___i2).order(:id).limit(2, 1).all.should == []
+    @ds.cross_join(:items2).order(:id).limit(2, 1).all.should == []
+    @ds.from(:items___i).cross_join(:items2___i2).order(:id).limit(2, 1).all.should == []
+    @ds.cross_join(:items2___i).cross_join(@db[:items2].select(:id2___id3, :number2___number3)).order(:id).limit(2, 1).all.should == []
+    @db.drop_table(:items2)
+  end
+  
+  cspecify "should fetch correctly with a limit and offset without an order", :db2, :mssql, :oracle do
     @ds.limit(2, 1).all.should == []
   end
 
+  specify "should fetch correctly with a limit in an IN subselect" do
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2)).all.should == [{:id=>1, :number=>10}]
+    @ds.insert(:number=>20)
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(1)).all.should == [{:id=>1, :number=>10}]
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2)).order(:id).all.should == [{:id=>1, :number=>10}, {:id=>2, :number=>20}]
+  end
+  
+  specify "should fetch correctly with a limit and offset in an IN subselect" do
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2, 0)).all.should == [{:id=>1, :number=>10}]
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2, 1)).all.should == []
+    @ds.insert(:number=>20)
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(1, 1)).all.should == [{:id=>2, :number=>20}]
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2, 0)).order(:id).all.should == [{:id=>1, :number=>10}, {:id=>2, :number=>20}]
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2, 1)).all.should == [{:id=>2, :number=>20}]
+  end
+  
   specify "should alias columns correctly" do
     @ds.select(:id___x, :number___n).first.should == {:x=>1, :n=>10}
   end
+
+  specify "should handle true/false properly" do
+    @ds.filter(Sequel::TRUE).select_map(:number).should == [10]
+    @ds.filter(Sequel::FALSE).select_map(:number).should == []
+    @ds.filter(true).select_map(:number).should == [10]
+    @ds.filter(false).select_map(:number).should == []
+  end
 end
 
 describe Sequel::Dataset do
@@ -95,7 +173,6 @@ describe Sequel::Dataset do
       Integer :value
     end
     @d = INTEGRATION_DB[:test]
-    clear_sqls
   end
   after do
     INTEGRATION_DB.drop_table(:test)
@@ -187,7 +264,11 @@ describe Sequel::Database do
     INTEGRATION_DB.drop_table(t) rescue nil
     INTEGRATION_DB.table_exists?(t).should == false
     INTEGRATION_DB.create_table(t){Integer :a}
-    INTEGRATION_DB.table_exists?(t).should == true
+    begin
+      INTEGRATION_DB.table_exists?(t).should == true
+    ensure
+      INTEGRATION_DB.drop_table(t)
+    end
   end
 end
 
@@ -251,18 +332,17 @@ end
 
 describe "Simple Dataset operations in transactions" do
   before do
-    INTEGRATION_DB.create_table!(:items_insert_in_transaction) do
+    INTEGRATION_DB.create_table!(:items) do
       primary_key :id
       integer :number
     end
-    @ds = INTEGRATION_DB[:items_insert_in_transaction]
-    clear_sqls
+    @ds = INTEGRATION_DB[:items]
   end
   after do
-    INTEGRATION_DB.drop_table(:items_insert_in_transaction)
+    INTEGRATION_DB.drop_table(:items)
   end
 
-  cspecify "should insert correctly with a primary key specified inside a transaction", :mssql do
+  cspecify "should insert correctly with a primary key specified inside a transaction", :db2, :mssql do
     INTEGRATION_DB.transaction do
       @ds.insert(:id=>100, :number=>20)
       @ds.count.should == 1
@@ -293,7 +373,6 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
     @ds2 = INTEGRATION_DB[:i2]
     @ds2.insert(:number=>10)
     @ds2.insert(:number=>30)
-    clear_sqls
   end
   
   specify "should give the correct results for simple UNION, EXCEPT, and INTERSECT" do
@@ -359,7 +438,7 @@ end
 
 if INTEGRATION_DB.dataset.supports_cte?
   describe "Common Table Expressions" do
-    before do
+    before(:all) do
       @db = INTEGRATION_DB
       @db.create_table!(:i1){Integer :id; Integer :parent_id}
       @ds = @db[:i1]
@@ -370,7 +449,7 @@ if INTEGRATION_DB.dataset.supports_cte?
       @ds.insert(:id=>5, :parent_id=>3)
       @ds.insert(:id=>6, :parent_id=>5)
     end
-    after do
+    after(:all) do
       @db.drop_table(:i1)
     end
     
@@ -378,7 +457,7 @@ if INTEGRATION_DB.dataset.supports_cte?
       @db[:t].with(:t, @ds.filter(:parent_id=>nil).select(:id)).order(:id).map(:id).should == [1, 2]
     end
     
-    specify "should give correct results for recursive WITH" do
+    cspecify "should give correct results for recursive WITH", :db2 do
       ds = @db[:t].select(:i___id, :pi___parent_id).with_recursive(:t, @ds.filter(:parent_id=>nil), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
       ds.all.should == [{:parent_id=>nil, :id=>1}, {:parent_id=>nil, :id=>2}, {:parent_id=>1, :id=>3}, {:parent_id=>1, :id=>4}, {:parent_id=>3, :id=>5}, {:parent_id=>5, :id=>6}]
       ps = @db[:t].select(:i___id, :pi___parent_id).with_recursive(:t, @ds.filter(:parent_id=>:$n), @ds.join(:t, :i=>:parent_id).filter(:t__i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi]).prepare(:select, :cte_sel)
@@ -391,12 +470,116 @@ if INTEGRATION_DB.dataset.supports_cte?
       @ds.inner_join(@db[:t].with(:t, @ds.filter(:parent_id=>nil)), :id => :id).select(:i1__id).order(:i1__id).map(:id).should == [1,2]
       @db[:t].with(:t, @ds).inner_join(@db[:s].with(:s, @ds.filter(:parent_id=>nil)), :id => :id).select(:t__id).order(:t__id).map(:id).should == [1,2]
     end
+
+    specify "should support a subselect in the FROM clause with a CTE" do
+      @ds.from(@db[:t].with(:t, @ds)).select_order_map(:id).should == [1,2,3,4,5,6]
+      @db[:t].with(:t, @ds).from_self.select_order_map(:id).should == [1,2,3,4,5,6]
+    end
+
+    specify "should support using a CTE inside a CTE" do
+      @db[:s].with(:s, @db[:t].with(:t, @ds)).select_order_map(:id).should == [1,2,3,4,5,6]
+      @db[:s].with_recursive(:s, @db[:t].with(:t, @ds), @db[:t2].with(:t2, @ds)).select_order_map(:id).should == [1,1,2,2,3,3,4,4,5,5,6,6]
+    end
+
+    specify "should support using a CTE inside UNION/EXCEPT/INTERSECT" do
+      @ds.union(@db[:t].with(:t, @ds)).select_order_map(:id).should == [1,2,3,4,5,6]
+      if @ds.supports_intersect_except?
+        @ds.intersect(@db[:t].with(:t, @ds)).select_order_map(:id).should == [1,2,3,4,5,6]
+        @ds.except(@db[:t].with(:t, @ds)).select_order_map(:id).should == []
+      end
+    end
+  end
+end
+
+if INTEGRATION_DB.dataset.supports_cte?(:update) # Assume INSERT and DELETE support as well
+  describe "Common Table Expressions in INSERT/UPDATE/DELETE" do
+    before do
+      @db = INTEGRATION_DB
+      @db.create_table!(:i1){Integer :id}
+      @ds = @db[:i1]
+      @ds2 = @ds.with(:t, @ds)
+      @ds.insert(:id=>1)
+      @ds.insert(:id=>2)
+    end
+    after do
+      @db.drop_table(:i1)
+    end
+    
+    specify "should give correct results for WITH" do
+      @ds2.insert(@db[:t])
+      @ds.select_order_map(:id).should == [1, 1, 2, 2]
+      @ds2.filter(:id=>@db[:t].select{max(id)}).update(:id=>:id+1)
+      @ds.select_order_map(:id).should == [1, 1, 3, 3]
+      @ds2.filter(:id=>@db[:t].select{max(id)}).delete
+      @ds.select_order_map(:id).should == [1, 1]
+    end
+  end
+end
+
+if INTEGRATION_DB.dataset.supports_returning?(:insert)
+  describe "RETURNING clauses in INSERT" do
+    before do
+      @db = INTEGRATION_DB
+      @db.create_table!(:i1){Integer :id; Integer :foo}
+      @ds = @db[:i1]
+    end
+    after do
+      @db.drop_table(:i1)
+    end
+    
+    specify "should give correct results" do
+      h = {}
+      @ds.returning(:foo).insert(1, 2){|r| h = r}
+      h.should == {:foo=>2}
+      @ds.returning(:id).insert(3, 4){|r| h = r}
+      h.should == {:id=>3}
+      @ds.returning.insert(5, 6){|r| h = r}
+      h.should == {:id=>5, :foo=>6}
+      @ds.returning(:id___foo, :foo___id).insert(7, 8){|r| h = r}
+      h.should == {:id=>8, :foo=>7}
+    end
+  end
+end
+
+if INTEGRATION_DB.dataset.supports_returning?(:update) # Assume DELETE support as well
+  describe "RETURNING clauses in UPDATE/DELETE" do
+    before do
+      @db = INTEGRATION_DB
+      @db.create_table!(:i1){Integer :id; Integer :foo}
+      @ds = @db[:i1]
+      @ds.insert(1, 2)
+    end
+    after do
+      @db.drop_table(:i1)
+    end
+    
+    specify "should give correct results" do
+      h = []
+      @ds.returning(:foo).update(:id=>:id+1, :foo=>:foo*2){|r| h << r}
+      h.should == [{:foo=>4}]
+      h.clear
+      @ds.returning(:id).update(:id=>:id+1, :foo=>:foo*2){|r| h << r}
+      h.should == [{:id=>3}]
+      h.clear
+      @ds.returning.update(:id=>:id+1, :foo=>:foo*2){|r| h << r}
+      h.should == [{:id=>4, :foo=>16}]
+      h.clear
+      @ds.returning(:id___foo, :foo___id).update(:id=>:id+1, :foo=>:foo*2){|r| h << r}
+      h.should == [{:id=>32, :foo=>5}]
+      h.clear
+
+      @ds.returning.delete{|r| h << r}
+      h.should == [{:id=>5, :foo=>32}]
+      h.clear
+      @ds.returning.delete{|r| h << r}
+      h.should == []
+    end
   end
 end
 
 if INTEGRATION_DB.dataset.supports_window_functions?
   describe "Window Functions" do
-    before do
+    before(:all) do
       @db = INTEGRATION_DB
       @db.create_table!(:i1){Integer :id; Integer :group_id; Integer :amount}
       @ds = @db[:i1].order(:id)
@@ -407,7 +590,7 @@ if INTEGRATION_DB.dataset.supports_window_functions?
       @ds.insert(:id=>5, :group_id=>2, :amount=>10000)
       @ds.insert(:id=>6, :group_id=>2, :amount=>100000)
     end
-    after do
+    after(:all) do
       @db.drop_table(:i1)
     end
     
@@ -435,21 +618,13 @@ if INTEGRATION_DB.dataset.supports_window_functions?
     cspecify "should give correct results for aggregate window functions with frames", :mssql do
       @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id, :frame=>:all){}.as(:sum)}.all.should ==
         [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :frame=>:all){}.as(:sum)}.all.should ==
-        [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
       @ds.select(:id){sum(:over, :args=>amount, :order=>id, :frame=>:all){}.as(:sum)}.all.should ==
         [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :frame=>:all){}.as(:sum)}.all.should ==
-        [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
         
       @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id, :frame=>:rows){}.as(:sum)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :frame=>:rows){}.as(:sum)}.all.should ==
-        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
       @ds.select(:id){sum(:over, :args=>amount, :order=>id, :frame=>:rows){}.as(:sum)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :frame=>:rows){}.as(:sum)}.all.should ==
-        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
     end
   end
 end
@@ -471,10 +646,10 @@ describe Sequel::SQL::Constants do
     @c2 = proc{|v| v.is_a?(Date) ? v : Date.parse(v) }
   end
   after do
-    @db.drop_table(:constants)
+    @db.drop_table(:constants) if @db.table_exists?(:constants)
   end
   
-  cspecify "should have working CURRENT_DATE", [:odbc, :mssql], [:jdbc, :sqlite] do
+  cspecify "should have working CURRENT_DATE", [:odbc, :mssql], [:jdbc, :sqlite], :oracle do
     @db.create_table!(:constants){Date :d}
     @ds.insert(:d=>Sequel::CURRENT_DATE)
     d = @c2[@ds.get(:d)]
@@ -485,26 +660,27 @@ describe Sequel::SQL::Constants do
   cspecify "should have working CURRENT_TIME", [:do, :mysql], [:jdbc, :sqlite], [:mysql2] do
     @db.create_table!(:constants){Time :t, :only_time=>true}
     @ds.insert(:t=>Sequel::CURRENT_TIME)
-    (Time.now - @c[@ds.get(:t)]).should be_within(1).of(0)
+    (Time.now - @c[@ds.get(:t)]).should be_within(2).of(0)
   end
 
   cspecify "should have working CURRENT_TIMESTAMP", [:jdbc, :sqlite] do
     @db.create_table!(:constants){DateTime :ts}
     @ds.insert(:ts=>Sequel::CURRENT_TIMESTAMP)
-    (Time.now - @c[@ds.get(:ts)]).should be_within(1).of(0)
+    (Time.now - @c[@ds.get(:ts)]).should be_within(2).of(0)
   end
 end
 
 describe "Sequel::Dataset#import and #multi_insert" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.create_table!(:imp){Integer :i}
-    @db.create_table!(:exp2){Integer :i}
     @ids = @db[:imp].order(:i)
-    @eds = @db[:exp2]
   end
-  after do
-    @db.drop_table(:imp, :exp2)
+  before do
+    @ids.delete
+  end
+  after(:all) do
+    @db.drop_table(:imp)
   end
 
   it "should import with multi_insert and an array of hashes" do
@@ -518,9 +694,11 @@ describe "Sequel::Dataset#import and #multi_insert" do
   end
 
   it "should import with a dataset" do
-    @eds.import([:i], [[10], [20]])
-    @ids.import([:i], @eds)
+    @db.create_table!(:exp2){Integer :i}
+    @db[:exp2].import([:i], [[10], [20]])
+    @ids.import([:i], @db[:exp2])
     @ids.all.should == [{:i=>10}, {:i=>20}]
+    @db.drop_table(:exp2)
   end
   
   it "should have import work with the :slice_size option" do
@@ -536,12 +714,15 @@ describe "Sequel::Dataset#import and #multi_insert" do
 end
 
 describe "Sequel::Dataset convenience methods" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.create_table!(:a){Integer :a; Integer :b}
     @ds = @db[:a].order(:a)
   end
-  after do
+  before do
+    @ds.delete
+  end
+  after(:all) do
     @db.drop_table(:a)
   end
   
@@ -577,7 +758,7 @@ describe "Sequel::Dataset convenience methods" do
     @ds.group_and_count(:a___c).order(:count).all.each{|h| h[:count] = h[:count].to_i}.should == [{:c=>30, :count=>1}, {:c=>20, :count=>2}]
   end
   
-  cspecify "#range should return the range between the maximum and minimum values", :sqlite do
+  specify "#range should return the range between the maximum and minimum values" do
     @ds = @ds.unordered
     @ds.insert(20, 10)
     @ds.insert(30, 10)
@@ -595,12 +776,15 @@ describe "Sequel::Dataset convenience methods" do
 end
   
 describe "Sequel::Dataset main SQL methods" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.create_table!(:a){Integer :a; Integer :b}
     @ds = @db[:a].order(:a)
   end
-  after do
+  before do
+    @ds.delete
+  end
+  after(:all) do
     @db.drop_table(:a)
   end
   
@@ -625,6 +809,23 @@ describe "Sequel::Dataset main SQL methods" do
     @ds.filter(:a=>20).or(:b=>15).all.should == [{:a=>20, :b=>30}]
     @ds.filter(:a=>10).or(:b=>15).all.should == []
   end
+
+  it "#select_group should work correctly" do
+    @ds.unordered!
+    @ds.select_group(:a).all.should == []
+    @ds.insert(20, 30)
+    @ds.select_group(:a).all.should == [{:a=>20}]
+    @ds.select_group(:b).all.should == [{:b=>30}]
+    @ds.insert(20, 40)
+    @ds.select_group(:a).all.should == [{:a=>20}]
+    @ds.order(:b).select_group(:b).all.should == [{:b=>30}, {:b=>40}]
+  end
+
+  it "#select_group should work correctly when aliasing" do
+    @ds.unordered!
+    @ds.insert(20, 30)
+    @ds.select_group(:b___c).all.should == [{:c=>30}]
+  end
   
   it "#having should work correctly" do
     @ds.unordered!
@@ -645,13 +846,92 @@ describe "Sequel::Dataset main SQL methods" do
   end
 end
 
-describe "Sequel::Dataset DSL support" do
+describe "Sequel::Dataset convenience methods" do
+  before(:all) do
+    @db = INTEGRATION_DB
+    @db.create_table!(:a){Integer :a; Integer :b; Integer :c; Integer :d}
+    @ds = @db[:a].order(:a)
+  end
   before do
+    @ds.delete
+    @ds.insert(1, 2, 3, 4)
+    @ds.insert(5, 6, 7, 8)
+  end
+  after(:all) do
+    @db.drop_table(:a)
+  end
+  
+  specify "should have working #map" do
+    @ds.map(:a).should == [1, 5]
+    @ds.map(:b).should == [2, 6]
+    @ds.map([:a, :b]).should == [[1, 2], [5, 6]]
+  end
+  
+  specify "should have working #to_hash" do
+    @ds.to_hash(:a).should == {1=>{:a=>1, :b=>2, :c=>3, :d=>4}, 5=>{:a=>5, :b=>6, :c=>7, :d=>8}}
+    @ds.to_hash(:b).should == {2=>{:a=>1, :b=>2, :c=>3, :d=>4}, 6=>{:a=>5, :b=>6, :c=>7, :d=>8}}
+    @ds.to_hash([:a, :b]).should == {[1, 2]=>{:a=>1, :b=>2, :c=>3, :d=>4}, [5, 6]=>{:a=>5, :b=>6, :c=>7, :d=>8}}
+
+    @ds.to_hash(:a, :b).should == {1=>2, 5=>6}
+    @ds.to_hash([:a, :c], :b).should == {[1, 3]=>2, [5, 7]=>6}
+    @ds.to_hash(:a, [:b, :c]).should == {1=>[2, 3], 5=>[6, 7]}
+    @ds.to_hash([:a, :c], [:b, :d]).should == {[1, 3]=>[2, 4], [5, 7]=>[6, 8]}
+  end
+
+  specify "should have working #select_map" do
+    @ds.select_map(:a).should == [1, 5]
+    @ds.select_map(:b).should == [2, 6]
+    @ds.select_map([:a]).should == [[1], [5]]
+    @ds.select_map([:a, :b]).should == [[1, 2], [5, 6]]
+
+    @ds.select_map(:a___e).should == [1, 5]
+    @ds.select_map(:b___e).should == [2, 6]
+    @ds.select_map([:a___e, :b___f]).should == [[1, 2], [5, 6]]
+    @ds.select_map([:a__a___e, :a__b___f]).should == [[1, 2], [5, 6]]
+    @ds.select_map([:a__a.as(:e), :a__b.as(:f)]).should == [[1, 2], [5, 6]]
+    @ds.select_map([:a.qualify(:a).as(:e), :b.qualify(:a).as(:f)]).should == [[1, 2], [5, 6]]
+    @ds.select_map([:a.identifier.qualify(:a).as(:e), :b.qualify(:a).as(:f)]).should == [[1, 2], [5, 6]]
+  end
+  
+  specify "should have working #select_order_map" do
+    @ds.select_order_map(:a).should == [1, 5]
+    @ds.select_order_map(:a__b.desc).should == [6, 2]
+    @ds.select_order_map(:a__b___e.desc).should == [6, 2]
+    @ds.select_order_map(:b.qualify(:a).as(:e)).should == [2, 6]
+    @ds.select_order_map([:a]).should == [[1], [5]]
+    @ds.select_order_map([:a.desc, :b]).should == [[5, 6], [1, 2]]
+
+    @ds.select_order_map(:a___e).should == [1, 5]
+    @ds.select_order_map(:b___e).should == [2, 6]
+    @ds.select_order_map([:a___e.desc, :b___f]).should == [[5, 6], [1, 2]]
+    @ds.select_order_map([:a__a___e.desc, :a__b___f]).should == [[5, 6], [1, 2]]
+    @ds.select_order_map([:a__a.desc, :a__b.as(:f)]).should == [[5, 6], [1, 2]]
+    @ds.select_order_map([:a.qualify(:a).desc, :b.qualify(:a).as(:f)]).should == [[5, 6], [1, 2]]
+    @ds.select_order_map([:a.identifier.qualify(:a).desc, :b.qualify(:a).as(:f)]).should == [[5, 6], [1, 2]]
+  end
+
+  specify "should have working #select_hash" do
+    @ds.select_hash(:a, :b).should == {1=>2, 5=>6}
+    @ds.select_hash(:a__a___e, :b).should == {1=>2, 5=>6}
+    @ds.select_hash(:a__a.as(:e), :b).should == {1=>2, 5=>6}
+    @ds.select_hash(:a.qualify(:a).as(:e), :b).should == {1=>2, 5=>6}
+    @ds.select_hash(:a.identifier.qualify(:a).as(:e), :b).should == {1=>2, 5=>6}
+    @ds.select_hash([:a, :c], :b).should == {[1, 3]=>2, [5, 7]=>6}
+    @ds.select_hash(:a, [:b, :c]).should == {1=>[2, 3], 5=>[6, 7]}
+    @ds.select_hash([:a, :c], [:b, :d]).should == {[1, 3]=>[2, 4], [5, 7]=>[6, 8]}
+  end
+end
+
+describe "Sequel::Dataset DSL support" do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.create_table!(:a){Integer :a; Integer :b}
     @ds = @db[:a].order(:a)
   end
-  after do
+  before do
+    @ds.delete
+  end
+  after(:all) do
     @db.drop_table(:a)
   end
   
@@ -663,31 +943,36 @@ describe "Sequel::Dataset DSL support" do
     @ds.get{a / b}.to_i.should == 2
   end
   
-  specify "should work with bitwise shift operators" do
+  cspecify "should work with bitwise shift operators", :derby do
     @ds.insert(3, 2)
     @ds.get{a.sql_number << b}.to_i.should == 12
     @ds.get{a.sql_number >> b}.to_i.should == 0
+    @ds.get{a.sql_number << b << 1}.to_i.should == 24
     @ds.delete
     @ds.insert(3, 1)
     @ds.get{a.sql_number << b}.to_i.should == 6
     @ds.get{a.sql_number >> b}.to_i.should == 1
+    @ds.get{a.sql_number >> b >> 1}.to_i.should == 0
   end
 
-  specify "should work with bitwise AND and OR operators" do
+  cspecify "should work with bitwise AND and OR operators", :derby do
     @ds.insert(3, 5)
     @ds.get{a.sql_number | b}.to_i.should == 7
     @ds.get{a.sql_number & b}.to_i.should == 1
+    @ds.get{a.sql_number | b | 8}.to_i.should == 15
+    @ds.get{a.sql_number & b & 8}.to_i.should == 0
   end
   
-  cspecify "should work with the bitwise compliment operator", :h2 do
+  specify "should work with the bitwise compliment operator" do
     @ds.insert(-3, 3)
     @ds.get{~a.sql_number}.to_i.should == 2
     @ds.get{~b.sql_number}.to_i.should == -4
   end
   
-  cspecify "should work with the bitwise xor operator", :sqlite do
+  cspecify "should work with the bitwise xor operator", :derby do
     @ds.insert(3, 5)
     @ds.get{a.sql_number ^ b}.to_i.should == 6
+    @ds.get{a.sql_number ^ b ^ 1}.to_i.should == 7
   end
   
   specify "should work with inequality operators" do
@@ -778,7 +1063,7 @@ describe "Sequel::Dataset DSL support" do
     @ds.filter({15=>20}.case(0, :a) > 0).all.should == []
   end
   
-  it "should work with multiple value arrays" do
+  specify "should work with multiple value arrays" do
     @ds.insert(20, 10)
     @ds.quote_identifiers = false
     @ds.filter([:a, :b]=>[[20, 10]].sql_array).all.should == [{:a=>20, :b=>10}]
@@ -847,22 +1132,29 @@ describe "SQL Extract Function" do
     @db.drop_table(:a)
   end
   
-  cspecify "should return the part of the datetime asked for", :sqlite, :mssql do
+  specify "should return the part of the datetime asked for" do
     t = Time.now
+    def @ds.supports_timestamp_timezones?() false end
     @ds.insert(t)
     @ds.get{a.extract(:year)}.should == t.year
     @ds.get{a.extract(:month)}.should == t.month
     @ds.get{a.extract(:day)}.should == t.day
+    @ds.get{a.extract(:hour)}.should == t.hour
+    @ds.get{a.extract(:minute)}.should == t.min
+    @ds.get{a.extract(:second)}.to_i.should == t.sec
   end
 end
 
 describe "Dataset string methods" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.create_table!(:a){String :a; String :b}
     @ds = @db[:a].order(:a)
   end
-  after do
+  before do
+    @ds.delete
+  end
+  after(:all) do
     @db.drop_table(:a)
   end
   
@@ -877,15 +1169,15 @@ describe "Dataset string methods" do
   end
   
   it "#grep should work with :all_patterns and :all_columns options" do
-    @ds.insert('foo bar', '')
+    @ds.insert('foo bar', ' ')
     @ds.insert('foo d', 'bar')
-    @ds.insert('foo e', '')
-    @ds.insert('', 'bar')
+    @ds.insert('foo e', ' ')
+    @ds.insert(' ', 'bar')
     @ds.insert('foo f', 'baz')
     @ds.insert('foo baz', 'bar baz')
     @ds.insert('foo boo', 'boo foo')
 
-    @ds.grep([:a, :b], %w'%foo% %bar%', :all_patterns=>true).all.should == [{:a=>'foo bar', :b=>''}, {:a=>'foo baz', :b=>'bar baz'}, {:a=>'foo d', :b=>'bar'}]
+    @ds.grep([:a, :b], %w'%foo% %bar%', :all_patterns=>true).all.should == [{:a=>'foo bar', :b=>' '}, {:a=>'foo baz', :b=>'bar baz'}, {:a=>'foo d', :b=>'bar'}]
     @ds.grep([:a, :b], %w'%foo% %bar% %blob%', :all_patterns=>true).all.should == []
 
     @ds.grep([:a, :b], %w'%bar% %foo%', :all_columns=>true).all.should == [{:a=>"foo baz", :b=>"bar baz"}, {:a=>"foo boo", :b=>"boo foo"}, {:a=>"foo d", :b=>"bar"}]
@@ -900,6 +1192,19 @@ describe "Dataset string methods" do
     @ds.filter(:a.like('foo')).all.should == [{:a=>'foo', :b=>'bar'}]
     @ds.filter(:a.like('bar')).all.should == []
     @ds.filter(:a.like('foo', 'bar')).all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.exclude(:a.like('foo')).all.should == []
+    @ds.exclude(:a.like('bar')).all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.exclude(:a.like('foo', 'bar')).all.should == []
+  end
+  
+  it "#like should be case sensitive" do
+    @ds.insert('foo', 'bar')
+    @ds.filter(:a.like('Foo')).all.should == []
+    @ds.filter(:a.like('baR')).all.should == []
+    @ds.filter(:a.like('FOO', 'BAR')).all.should == []
+    @ds.exclude(:a.like('Foo')).all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.exclude(:a.like('baR')).all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.exclude(:a.like('FOO', 'BAR')).all.should == [{:a=>'foo', :b=>'bar'}]
   end
   
   it "#ilike should return matching rows, in a case insensitive manner" do
@@ -907,6 +1212,9 @@ describe "Dataset string methods" do
     @ds.filter(:a.ilike('Foo')).all.should == [{:a=>'foo', :b=>'bar'}]
     @ds.filter(:a.ilike('baR')).all.should == []
     @ds.filter(:a.ilike('FOO', 'BAR')).all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.exclude(:a.ilike('Foo')).all.should == []
+    @ds.exclude(:a.ilike('baR')).all.should == [{:a=>'foo', :b=>'bar'}]
+    @ds.exclude(:a.ilike('FOO', 'BAR')).all.should == []
   end
   
   it "should work with strings created with sql_string_join" do
@@ -917,7 +1225,7 @@ describe "Dataset string methods" do
 end
 
 describe "Dataset identifier methods" do
-  before do
+  before(:all) do
     class ::String
       def uprev
         upcase.reverse
@@ -925,10 +1233,12 @@ describe "Dataset identifier methods" do
     end
     @db = INTEGRATION_DB
     @db.create_table!(:a){Integer :ab}
+    @db[:a].insert(1)
+  end
+  before do
     @ds = @db[:a].order(:ab)
-    @ds.insert(1)
   end
-  after do
+  after(:all) do
     @db.drop_table(:a)
   end
   
@@ -946,12 +1256,15 @@ describe "Dataset identifier methods" do
 end
 
 describe "Dataset defaults and overrides" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.create_table!(:a){Integer :a}
     @ds = @db[:a].order(:a)
   end
-  after do
+  before do
+    @ds.delete
+  end
+  after(:all) do
     @db.drop_table(:a)
   end