sequel 3.21.0 → 3.36.0

data/spec/integration/schema_test.rb

@@ -1,35 +1,59 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
-if INTEGRATION_DB.respond_to?(:schema_parse_table, true)
 describe "Database schema parser" do
   before do
     @iom = INTEGRATION_DB.identifier_output_method
     @iim = INTEGRATION_DB.identifier_input_method
     @defsch = INTEGRATION_DB.default_schema
-    clear_sqls
+    @qi = INTEGRATION_DB.quote_identifiers?
   end
   after do
     INTEGRATION_DB.identifier_output_method = @iom
     INTEGRATION_DB.identifier_input_method = @iim
     INTEGRATION_DB.default_schema = @defsch
-    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+    INTEGRATION_DB.quote_identifiers = @qi
+    INTEGRATION_DB.drop_table?(: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
 
@@ -56,11 +80,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}
@@ -85,7 +108,7 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == 'blah'
   end
 
-  specify "should parse types from the schema properly" 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}
@@ -113,17 +136,20 @@ describe "Database schema parser" do
     INTEGRATION_DB.create_table!(:items){FalseClass :number}
     INTEGRATION_DB.schema(:items).first.last[:type].should == :boolean
   end
-end
-end
+end if INTEGRATION_DB.respond_to?(:schema_parse_table, true)
 
-begin
-  INTEGRATION_DB.drop_table(:blah) rescue nil
+test_indexes = begin
+  INTEGRATION_DB.drop_table?(:blah)
   INTEGRATION_DB.indexes(:blah)
+  true
 rescue Sequel::NotImplemented
+  false
 rescue
+  true
+end
 describe "Database index parsing" do
   after do
-    INTEGRATION_DB.drop_table(:items)
+    INTEGRATION_DB.drop_table?(:items)
   end
 
   specify "should parse indexes into a hash" do
@@ -149,17 +175,71 @@ describe "Database index parsing" do
     INTEGRATION_DB.create_table!(:items){Integer :n; Integer :a; primary_key [:n, :a]}
     INTEGRATION_DB.indexes(:items).should == {}
   end
+end if test_indexes
+
+test_foreign_key_list = begin
+  INTEGRATION_DB.drop_table?(:blah)
+  INTEGRATION_DB.foreign_key_list(:blah)
+  true
+rescue Sequel::NotImplemented
+  false
+rescue
+  true
 end
-end
+describe "Database foreign key parsing" do
+  before do
+    @db = INTEGRATION_DB
+    @pr = lambda do |table, *expected|
+      actual = @db.foreign_key_list(table).sort_by{|c| c[:columns].map{|s| s.to_s}.join << (c[:key]||[]).map{|s| s.to_s}.join}.map{|v| v.values_at(:columns, :table, :key)}
+      actual.zip(expected).each do |a, e|
+        if e.last.first == :pk
+          if a.last == nil
+            a.pop
+            e.pop
+          else
+           e.last.shift
+          end
+        end
+        a.should == e
+      end
+      actual.length.should == expected.length
+    end
+  end
+  after do
+    @db.drop_table?(:b, :a)
+  end
+
+  specify "should parse foreign key information into an array of hashes" do
+    @db.create_table!(:a, :engine=>:InnoDB){primary_key :c; Integer :d; index :d, :unique=>true}
+    @db.create_table!(:b, :engine=>:InnoDB){foreign_key :e, :a}
+    @pr[:a]
+    @pr[:b, [[:e], :a, [:pk, :c]]]
+
+    @db.alter_table(:b){add_foreign_key :f, :a, :key=>[:d]}
+    @pr[:b, [[:e], :a, [:pk, :c]], [[:f], :a, [:d]]]
+
+    @db.alter_table(:b){add_foreign_key [:f], :a, :key=>[:c]}
+    @pr[:b, [[:e], :a, [:pk, :c]], [[:f], :a, [:c]], [[:f], :a, [:d]]]
+
+    @db.alter_table(:a){add_index [:d, :c], :unique=>true}
+    @db.alter_table(:b){add_foreign_key [:f, :e], :a, :key=>[:d, :c]}
+    @pr[:b, [[:e], :a, [:pk, :c]], [[:f], :a, [:c]], [[:f], :a, [:d]], [[:f, :e], :a, [:d, :c]]]
+  end
+
+  specify "should handle composite foreign and primary keys" do
+    @db.create_table!(:a, :engine=>:InnoDB){Integer :b; Integer :c; primary_key [:b, :c]; index [:c, :b], :unique=>true}
+    @db.create_table!(:b, :engine=>:InnoDB){Integer :e; Integer :f; foreign_key [:e, :f], :a; foreign_key [:f, :e], :a, :key=>[:c, :b]}
+    @pr[:b, [[:e, :f], :a, [:pk, :b, :c]], [[:f, :e], :a, [:c, :b]]]
+  end
+end if test_foreign_key_list
 
 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)
+    @db.drop_table?(:items, :items2)
   end
 
   specify "should create tables correctly" do
@@ -170,12 +250,60 @@ describe "Database schema modifiers" do
     @ds.columns!.should == [:number]
   end
   
+  specify "should create tables from select statements correctly" do
+    @db.create_table!(:items){Integer :number}
+    @ds.insert([10])
+    @db.create_table(:items2, :as=>@db[:items])
+    @db.schema(:items2, :reload=>true).map{|x| x.first}.should == [:number]
+    @db[:items2].columns.should == [:number]
+    @db[:items2].all.should == [{:number=>10}]
+  end
+  
+  specify "should handle create table in a rolled back transaction" do
+    @db.drop_table?(:items)
+    @db.transaction(:rollback=>:always){@db.create_table(:items){Integer :number}}
+    @db.table_exists?(:items).should be_false
+  end if INTEGRATION_DB.supports_transactional_ddl?
+  
+  describe "join tables" do
+    after do
+      @db.drop_join_table(:cat_id=>:cats, :dog_id=>:dogs) if @db.table_exists?(:cats_dogs)
+      @db.drop_table(:cats, :dogs)
+      @db.table_exists?(:cats_dogs).should == false
+    end
+
+    specify "should create join tables correctly" do
+      @db.create_table!(:cats){primary_key :id}
+      @db.create_table!(:dogs){primary_key :id}
+      @db.create_join_table(:cat_id=>:cats, :dog_id=>:dogs)
+      @db.table_exists?(:cats_dogs).should == true
+    end
+  end
+
   specify "should create temporary tables without raising an exception" do
     @db.create_table!(:items, :temp=>true){Integer :number}
   end
   
+  specify "should have create_table? only create the table if it doesn't already exist" do
+    @db.create_table!(:items){String :a}
+    @db.create_table?(:items){String :b}
+    @db[:items].columns.should == [:a]
+    @db.drop_table?(:items)
+    @db.create_table?(:items){String :b}
+    @db[:items].columns.should == [:b]
+  end
+
+  specify "should have create_table? work correctly with indexes" do
+    @db.create_table!(:items){String :a, :index=>true}
+    @db.create_table?(:items){String :b, :index=>true}
+    @db[:items].columns.should == [:a]
+    @db.drop_table?(:items)
+    @db.create_table?(:items){String :b, :index=>true}
+    @db[:items].columns.should == [:b]
+  end
+
   specify "should rename tables correctly" do
-    @db.drop_table(:items) rescue nil
+    @db.drop_table?(:items)
     @db.create_table!(:items2){Integer :number}
     @db.rename_table(:items2, :items)
     @db.table_exists?(:items).should == true
@@ -215,24 +343,34 @@ describe "Database schema modifiers" do
   specify "should add columns to tables correctly" do
     @db.create_table!(:items){Integer :number}
     @ds.insert(:number=>10)
-    @db.alter_table(:items){add_column :name, :text}
+    @db.alter_table(:items){add_column :name, String}
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name]
     @ds.columns!.should == [:number, :name]
     @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}
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :id]
     @ds.columns!.should == [:number, :id]
     @ds.map(:number).should == [10]
+    proc{@ds.insert(:id=>@ds.map(:id).first)}.should raise_error
+  end
+
+  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}
+    @ds.map(:number).should == [10]
+    proc{@ds.insert(10)}.should_not raise_error
   end
 
   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]
@@ -269,7 +407,22 @@ describe "Database schema modifiers" do
     proc{@ds.insert(:n=>nil)}.should raise_error(Sequel::DatabaseError)
   end
 
-  specify "should set column NULL/NOT NULL correctly" do
+  specify "should rename columns when the table is referenced by a foreign key" do
+    begin
+      @db.create_table!(:itemsfk){primary_key :id; Integer :a}
+      @db.create_table!(:items){foreign_key :id, :itemsfk}
+      @db[:itemsfk].insert(:a=>10)
+      @ds.insert(:id=>1)
+      @db.alter_table(:itemsfk){rename_column :a, :b}
+      @db[:itemsfk].insert(:b=>20)
+      @ds.insert(:id=>2)
+      @db[:itemsfk].select_order_map([:id, :b]).should == [[1, 10], [2, 20]]
+    ensure
+      @db.drop_table(:items, :itemsfk)
+    end
+  end
+
+  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}
@@ -277,7 +430,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
 
@@ -291,28 +444,92 @@ describe "Database schema modifiers" do
     @ds.all.should == [{:id=>10}, {:id=>20}]
   end
 
-  specify "should set column types correctly" 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 unique constraints and foreign key table constraints correctly", :sqlite do
-    @db.create_table!(:items){Integer :id; Integer :item_id}
+  cspecify "should set column types without modifying NULL/NOT NULL", [:jdbc, :db2], [:db2], :oracle, :derby do
+    @db.create_table!(:items){Integer :id, :null=>false, :default=>2}
+    proc{@ds.insert(:id=>nil)}.should raise_error(Sequel::DatabaseError)
+    @db.alter_table(:items){set_column_type :id, String}
+    proc{@ds.insert(:id=>nil)}.should raise_error(Sequel::DatabaseError)
+
+    @db.create_table!(:items){Integer :id}
+    @ds.insert(:id=>nil)
+    @db.alter_table(:items){set_column_type :id, String}
+    @ds.insert(:id=>nil)
+    @ds.map(:id).should == [nil, nil]
+  end
+
+  cspecify "should set column types without modifying defaults", [:jdbc, :db2], [:db2], :oracle, :derby do
+    @db.create_table!(:items){Integer :id, :default=>0}
+    @ds.insert
+    @ds.map(:id).should == [0]
+    @db.alter_table(:items){set_column_type :id, String}
+    @ds.insert
+    @ds.map(:id).should == ['0', '0']
+
+    @db.create_table!(:items){String :id, :default=>'a'}
+    @ds.insert
+    @ds.map(:id).should == %w'a'
+    @db.alter_table(:items){set_column_type :id, String, :size=>1}
+    @ds.insert
+    @ds.map(:id).should == %w'a a'
+  end
+
+  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]
       add_foreign_key [:id, :item_id], :items, :key=>[:item_id, :id]
     end
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
     @ds.columns!.should == [:id, :item_id]
+    proc{@ds.insert(1, 1)}.should_not raise_error
+    proc{@ds.insert(1, 1)}.should raise_error
+    proc{@ds.insert(1, 2)}.should raise_error
   end
 
-  cspecify "should remove columns from tables correctly", :h2, :mssql 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
+      add_foreign_key [:id, :item_id], :items, :key=>[:item_id, :id], :name=>:fk_iii
+    end
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @ds.columns!.should == [:id, :item_id]
+    proc{@ds.insert(1, 1)}.should_not raise_error
+    proc{@ds.insert(1, 1)}.should raise_error
+    proc{@ds.insert(1, 2)}.should raise_error
+  end
+
+  specify "should drop unique constraints and foreign key table constraints correctly" do
     @db.create_table!(:items) do
+      Integer :id
+      Integer :item_id
+      unique [:item_id, :id], :name=>:items_uk
+      foreign_key [:id, :item_id], :items, :key=>[:item_id, :id], :name=>:items_fk
+    end
+    @db.alter_table(:items) do
+      drop_constraint(:items_fk, :type=>:foreign_key)
+      drop_constraint(:items_uk, :type=>:unique)
+    end
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @ds.columns!.should == [:id, :item_id]
+    proc{@ds.insert(1, 2)}.should_not raise_error
+    proc{@ds.insert(1, 2)}.should_not raise_error
+  end
+
+  cspecify "should remove columns from tables correctly", :h2, :mssql, [:jdbc, :db2], :hsqldb do
+    # MySQL with InnoDB cannot drop foreign key columns unless you know the
+    # name of the constraint, see Bug #14347
+    @db.create_table!(:items, :engine=>:MyISAM) do
       primary_key :id
       String :name
       Integer :number
@@ -332,7 +549,7 @@ describe "Database schema modifiers" do
     @ds.columns!.should == [:id]
   end
 
-  specify "should remove multiple columns in a single alter_table block" do
+  cspecify "should remove multiple columns in a single alter_table block", [:jdbc, :db2] do
     @db.create_table!(:items) do
       primary_key :id
       String :name
@@ -350,10 +567,12 @@ describe "Database schema modifiers" do
   end
 end
 
-begin
+test_tables = begin
   INTEGRATION_DB.tables
+  true
 rescue Sequel::NotImplemented
-rescue
+  false
+end
 describe "Database#tables" do
   before do
     class ::String
@@ -362,25 +581,72 @@ describe "Database#tables" do
         "xxxxx#{@@xxxxx += 1}"
       end
     end
-    @iom = INTEGRATION_DB.identifier_output_method
-    @iim = INTEGRATION_DB.identifier_input_method
-    clear_sqls
+    @db = INTEGRATION_DB
+    @db.create_table(:sequel_test_table){Integer :a}
+    @db.create_view :sequel_test_view, @db[:sequel_test_table]
+    @iom = @db.identifier_output_method
+    @iim = @db.identifier_input_method
   end
   after do
-    INTEGRATION_DB.identifier_output_method = @iom
-    INTEGRATION_DB.identifier_input_method = @iim
+    @db.identifier_output_method = @iom
+    @db.identifier_input_method = @iim
+    @db.drop_view :sequel_test_view
+    @db.drop_table :sequel_test_table
   end
 
   specify "should return an array of symbols" do
-    ts = INTEGRATION_DB.tables
+    ts = @db.tables
     ts.should be_a_kind_of(Array)
     ts.each{|t| t.should be_a_kind_of(Symbol)}
+    ts.should include(:sequel_test_table)
+    ts.should_not include(:sequel_test_view)
   end
 
   specify "should respect the database's identifier_output_method" do
-    INTEGRATION_DB.identifier_output_method = :xxxxx
-    INTEGRATION_DB.identifier_input_method = :xxxxx
-    INTEGRATION_DB.tables.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
+    @db.identifier_output_method = :xxxxx
+    @db.identifier_input_method = :xxxxx
+    @db.tables.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
   end
+end if test_tables
+
+test_views = begin
+  INTEGRATION_DB.views
+  true
+rescue Sequel::NotImplemented
+  false
 end
-end
+describe "Database#views" do
+  before do
+    class ::String
+      @@xxxxx = 0
+      def xxxxx
+        "xxxxx#{@@xxxxx += 1}"
+      end
+    end
+    @db = INTEGRATION_DB
+    @db.create_table(:sequel_test_table){Integer :a}
+    @db.create_view :sequel_test_view, @db[:sequel_test_table]
+    @iom = @db.identifier_output_method
+    @iim = @db.identifier_input_method
+  end
+  after do
+    @db.identifier_output_method = @iom
+    @db.identifier_input_method = @iim
+    @db.drop_view :sequel_test_view
+    @db.drop_table :sequel_test_table
+  end
+
+  specify "should return an array of symbols" do
+    ts = @db.views
+    ts.should be_a_kind_of(Array)
+    ts.each{|t| t.should be_a_kind_of(Symbol)}
+    ts.should_not include(:sequel_test_table)
+    ts.should include(:sequel_test_view)
+  end
+
+  specify "should respect the database's identifier_output_method" do
+    @db.identifier_output_method = :xxxxx
+    @db.identifier_input_method = :xxxxx
+    @db.views.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
+  end
+end if test_views

data/spec/integration/spec_helper.rb

@@ -9,12 +9,13 @@ begin
 rescue LoadError
 end
 
-Sequel::Model.use_transactions = false
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
 
-$sqls = []
-def clear_sqls
-  $sqls.clear
-end 
+Sequel::Model.use_transactions = false
+Sequel::Model.cache_anonymous_models = false
 
 unless defined?(RSpec)
   module Spec::Matchers
@@ -29,45 +30,45 @@ unless defined?(RSpec)
   end
 end
 
-(defined?(RSpec) ? RSpec::Core::ExampleGroup : Spec::Example::ExampleGroup).class_eval do
-  def log
-    begin
-      INTEGRATION_DB.loggers << Logger.new(STDOUT)
-      yield
-    ensure
-     INTEGRATION_DB.loggers.pop
-    end
-  end
-  
-  def self.log_specify(message, &block)
-    specify(message){log{instance_eval(&block)}}
-  end
-
-  def self.cspecify(message, *checked, &block)
-    pending = false
+def Sequel.guarded?(*checked)
+  unless ENV['SEQUEL_NO_PENDING']
     checked.each do |c|
       case c
       when INTEGRATION_DB.database_type
-        pending = c
+        return c
       when Array
         case c.length
         when 1
-          pending = c if c.first == INTEGRATION_DB.adapter_scheme
+          return c if c.first == INTEGRATION_DB.adapter_scheme
         when 2
           if c.first.is_a?(Proc)
-            pending = c if c.first.call(INTEGRATION_DB) && c.last == INTEGRATION_DB.database_type
+            return c if c.first.call(INTEGRATION_DB) && c.last == INTEGRATION_DB.database_type
           elsif c.last.is_a?(Proc)
-            pending = c if c.first == INTEGRATION_DB.adapter_scheme && c.last.call(INTEGRATION_DB)
+            return c if c.first == INTEGRATION_DB.adapter_scheme && c.last.call(INTEGRATION_DB)
           else
-            pending = c if c.first == INTEGRATION_DB.adapter_scheme && c.last == INTEGRATION_DB.database_type
+            return c if c.first == INTEGRATION_DB.adapter_scheme && c.last == INTEGRATION_DB.database_type
           end
         when 3
-          pending = c if c[0] == INTEGRATION_DB.adapter_scheme && c[1] == INTEGRATION_DB.database_type && c[2].call(INTEGRATION_DB)
+          return c if c[0] == INTEGRATION_DB.adapter_scheme && c[1] == INTEGRATION_DB.database_type && c[2].call(INTEGRATION_DB)
         end          
       end
-      break if pending
     end
-    if pending
+  end
+  false
+end
+
+(defined?(RSpec) ? RSpec::Core::ExampleGroup : Spec::Example::ExampleGroup).class_eval do
+  def log
+    begin
+      INTEGRATION_DB.loggers << Logger.new(STDOUT)
+      yield
+    ensure
+     INTEGRATION_DB.loggers.pop
+    end
+  end
+  
+  def self.cspecify(message, *checked, &block)
+    if pending = Sequel.guarded?(*checked)
       specify(message){pending("Not yet working on #{Array(pending).join(', ')}", &block)}
     else
       specify(message, &block)
@@ -82,5 +83,14 @@ if defined?(INTEGRATION_DB) || defined?(INTEGRATION_URL) || ENV['SEQUEL_INTEGRAT
     #INTEGRATION_DB.instance_variable_set(:@server_version, 80100)
   end
 else
-  INTEGRATION_DB = Sequel.sqlite('', :quote_identifiers=>false)
+  INTEGRATION_DB = Sequel.sqlite
+end
+
+if INTEGRATION_DB.adapter_scheme == :ibmdb
+  def INTEGRATION_DB.drop_table(*tables)
+    super
+  rescue Sequel::DatabaseError
+    disconnect
+    super
+  end
 end