sequel 5.28.0 → 5.33.0

data/spec/integration/spec_helper.rb

@@ -1,71 +0,0 @@
-require 'logger'
-require_relative "../sequel_warning"
-
-if ENV['COVERAGE']
-  require_relative "../sequel_coverage"
-  SimpleCov.sequel_coverage(:group=>%r{lib/sequel/adapters})
-end
-
-$:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-require_relative "../../lib/sequel"
-
-begin
-  require_relative "../spec_config" unless defined?(DB)
-rescue LoadError
-end
-Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_(spec|test)\.rb/}
-
-Sequel::DB = nil unless Sequel.constants.include?(:DB)
-Sequel.split_symbols = true if ENV['SEQUEL_SPLIT_SYMBOLS']
-Sequel::Database.extension :columns_introspection if ENV['SEQUEL_COLUMNS_INTROSPECTION']
-Sequel::Model.cache_associations = false if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']
-Sequel::Model.plugin :prepared_statements if ENV['SEQUEL_MODEL_PREPARED_STATEMENTS']
-Sequel::Model.plugin :throw_failures if ENV['SEQUEL_MODEL_THROW_FAILURES']
-Sequel::Model.use_transactions = false
-Sequel::Model.cache_anonymous_models = false
-
-require_relative '../guards_helper'
-
-DB = Sequel.connect(ENV['SEQUEL_INTEGRATION_URL']) unless defined?(DB)
-
-IDENTIFIER_MANGLING = !!ENV['SEQUEL_IDENTIFIER_MANGLING'] unless defined?(IDENTIFIER_MANGLING)
-DB.extension(:identifier_mangling) if IDENTIFIER_MANGLING
-
-if DB.adapter_scheme == :ibmdb || (DB.adapter_scheme == :ado && DB.database_type == :access)
-  def DB.drop_table(*tables)
-    super
-  rescue Sequel::DatabaseError
-    disconnect
-    super
-  end
-end
-
-DB.extension :index_caching if ENV['SEQUEL_INDEX_CACHING']
-DB.extension :error_sql if ENV['SEQUEL_ERROR_SQL']
-DB.extension :synchronize_sql if ENV['SEQUEL_SYNCHRONIZE_SQL']
-DB.extension :integer64 if ENV['SEQUEL_INTEGER64']
-
-if ENV['SEQUEL_CONNECTION_VALIDATOR']
-  ENV['SEQUEL_NO_CHECK_SQLS'] = '1'
-  DB.extension(:connection_validator)
-  DB.pool.connection_validation_timeout = -1
-end
-
-if dch = ENV['SEQUEL_DUPLICATE_COLUMNS_HANDLER']
-  DB.extension :duplicate_columns_handler
-  DB.opts[:on_duplicate_columns] = dch.to_sym unless dch.empty?
-end
-
-if ENV['SEQUEL_FREEZE_DATABASE']
-  DB.extension(:constraint_validations, :string_agg, :date_arithmetic)
-  DB.extension(:pg_array) if DB.database_type == :postgres
-  DB.freeze
-end
-
-version = if DB.respond_to?(:server_version)
-  DB.server_version
-elsif DB.respond_to?(:sqlite_version)
-  DB.sqlite_version
-end
-
-puts "running #{defined?(SEQUEL_ADAPTER_TEST) ? SEQUEL_ADAPTER_TEST : "integration (database type: #{DB.database_type})"} specs on #{RUBY_ENGINE} #{defined?(JRUBY_VERSION) ? JRUBY_VERSION : RUBY_VERSION} with #{DB.adapter_scheme} adapter#{" (database version: #{version})" if version}"

data/spec/integration/timezone_test.rb

@@ -1,86 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel timezone support" do
-  def _test_timezone(timezone=Sequel.application_timezone)
-    Sequel.datetime_class = Time
-    # Tests should cover both DST and non-DST times.
-    [Time.now, Time.local(2010,1,1,12), Time.local(2010,6,1,12)].each do |t|
-      @db[:t].insert(t)
-      t2 = @db[:t].single_value
-      t2 = @db.to_application_timestamp(t2.to_s) unless t2.is_a?(Time)
-      (t2 - t).must_be_close_to 0, 2
-      t2.utc_offset.must_equal 0 if timezone == :utc
-      t2.utc_offset.must_equal t.getlocal.utc_offset if timezone == :local
-      @db[:t].delete
-    end
-
-    Sequel.datetime_class = DateTime
-    local_dst_offset = Time.local(2010, 6).utc_offset/86400.0
-    local_std_offset = Time.local(2010, 1).utc_offset/86400.0
-    [DateTime.now, DateTime.civil(2010,1,1,12,0,0,local_std_offset), DateTime.civil(2010,6,1,12,0,0,local_dst_offset)].each do |dt|
-      @db[:t].insert(dt)
-      dt2 = @db[:t].single_value
-      dt2 = @db.to_application_timestamp(dt2.to_s) unless dt2.is_a?(DateTime)
-      (dt2 - dt).must_be_close_to 0, 0.00002
-      dt2.offset.must_equal 0 if timezone == :utc
-      dt2.offset.must_equal dt.offset if timezone == :local
-      @db[:t].delete
-    end
-  end
-
-  before do
-    @db = DB
-    @db.create_table!(:t){DateTime :t}
-  end
-  after do
-    @db.timezone = nil
-    Sequel.default_timezone = nil
-    Sequel.datetime_class = Time
-    @db.drop_table(:t)
-  end
-
-  cspecify "should support using UTC for database storage and local time for the application", [:tinytds], [:oracle] do
-    Sequel.database_timezone = :utc
-    Sequel.application_timezone = :local
-    _test_timezone
-    Sequel.database_timezone = nil
-    @db.timezone = :utc
-    _test_timezone
-  end
-
-  cspecify "should support using local time for database storage and UTC for the application", [:tinytds], [:oracle] do
-    Sequel.database_timezone = :local
-    Sequel.application_timezone = :utc
-    _test_timezone
-    Sequel.database_timezone = nil
-    @db.timezone = :local
-    _test_timezone
-  end
-
-  cspecify "should support using UTC for both database storage and for application", [:oracle] do
-    Sequel.default_timezone = :utc
-    _test_timezone
-    Sequel.database_timezone = :local
-    @db.timezone = :utc
-    _test_timezone
-  end
-
-  cspecify "should support using local time for both database storage and for application", [:oracle] do
-    Sequel.default_timezone = :local
-    _test_timezone
-    Sequel.database_timezone = :utc
-    @db.timezone = :local
-    _test_timezone
-  end
-
-  it "should allow overriding the database_timezone on a per-database basis" do
-    Sequel.database_timezone = :utc
-    @db.timezone = :local
-    t = Time.now
-    @db[:t].insert(t)
-    s = @db[:t].get(Sequel.cast(:t, String))
-    if o = Date._parse(s)[:offset]
-      o.must_equal t.utc_offset
-    end
-  end
-end unless DB.frozen?

data/spec/integration/transaction_test.rb

@@ -1,603 +0,0 @@
-require_relative "spec_helper"
-
-describe "Database transactions" do
-  before(:all) do
-    @db = DB
-    @db.create_table!(:items, :engine=>'InnoDB'){String :name; Integer :value}
-    @d = @db[:items]
-  end
-  before do
-    @d.delete
-  end
-  after(:all) do
-    @db.drop_table?(:items)
-  end
-
-  it "should support transactions" do
-    @db.transaction{@d.insert(:name => 'abc', :value => 1)}
-    @d.count.must_equal 1
-  end
-
-  it "should have #transaction yield the connection" do
-    @db.transaction{|conn| conn.wont_equal nil}
-  end
-
-  it "should have #in_transaction? work correctly" do
-    @db.in_transaction?.must_equal false
-    c = nil
-    @db.transaction{c = @db.in_transaction?}
-    c.must_equal true
-  end
-
-  it "should correctly rollback transactions" do
-    proc do
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        raise Interrupt, 'asdf'
-      end
-    end.must_raise(Interrupt)
-
-    @db.transaction do
-      @d.insert(:name => 'abc', :value => 1)
-      raise Sequel::Rollback
-    end.must_be_nil
-
-    proc do
-      @db.transaction(:rollback=>:reraise) do
-        @d.insert(:name => 'abc', :value => 1)
-        raise Sequel::Rollback
-      end
-    end.must_raise(Sequel::Rollback)
-
-    @db.transaction(:rollback=>:always) do
-      @d.insert(:name => 'abc', :value => 1)
-      2
-    end.must_equal 2
-
-    @d.count.must_equal 0
-  end
-
-  it "should support nested transactions" do
-    @db.transaction do
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-      end 
-    end 
-    @d.count.must_equal 1
-
-    @d.delete
-    @db.transaction do
-      @d.insert(:name => 'abc', :value => 1)
-      @db.transaction do
-        raise Sequel::Rollback
-      end 
-    end
-    @d.count.must_equal 0
-
-    proc {@db.transaction do
-      @d.insert(:name => 'abc', :value => 1)
-      @db.transaction do
-        raise Interrupt, 'asdf'
-      end 
-    end}.must_raise(Interrupt)
-    @d.count.must_equal 0
-  end 
-
-  it "should support rollback_on_exit" do
-    @db.transaction do
-      @d.insert(:name => 'abc', :value => 1)
-      @db.rollback_on_exit
-    end
-    @d.must_be_empty
-
-    catch(:foo) do
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.rollback_on_exit
-        throw :foo
-      end
-    end
-    @d.must_be_empty
-
-    lambda do
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.rollback_on_exit
-        return true
-      end
-    end
-    @d.must_be_empty
-
-    @db.transaction do
-      @d.insert(:name => 'abc', :value => 1)
-      @db.rollback_on_exit
-      @db.rollback_on_exit(:cancel=>true)
-    end
-    @d.count.must_equal 1
-
-    @d.delete
-    @db.transaction do
-      @d.insert(:name => 'abc', :value => 1)
-      @db.rollback_on_exit(:cancel=>true)
-    end
-    @d.count.must_equal 1
-
-    @d.delete
-    @db.transaction do
-      @d.insert(:name => 'abc', :value => 1)
-      @db.rollback_on_exit
-      @db.rollback_on_exit(:cancel=>true)
-      @db.rollback_on_exit
-    end
-    @d.must_be_empty
-  end
-  
-  if DB.supports_savepoints?
-    it "should support rollback_on_exit inside savepoints" do
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.transaction(:savepoint=>true) do
-          @d.insert(:name => 'def', :value => 2)
-          @db.rollback_on_exit
-        end
-      end
-      @d.must_be_empty
-
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.transaction(:savepoint=>true) do
-          @d.insert(:name => 'def', :value => 2)
-          @db.rollback_on_exit
-          @db.transaction(:savepoint=>true) do
-            @d.insert(:name => 'ghi', :value => 3)
-          end
-        end
-      end
-      @d.must_be_empty
-
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.transaction(:savepoint=>true) do
-          @d.insert(:name => 'def', :value => 2)
-          @db.transaction(:savepoint=>true) do
-            @db.rollback_on_exit
-            @d.insert(:name => 'ghi', :value => 3)
-          end
-        end
-      end
-      @d.must_be_empty
-    end
-
-    it "should support rollback_on_exit with :savepoint option" do
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.transaction(:savepoint=>true) do
-          @d.insert(:name => 'def', :value => 2)
-          @db.rollback_on_exit(:savepoint=>true)
-        end
-      end
-      @d.select_order_map(:value).must_equal [1]
-
-      @d.delete
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.transaction(:savepoint=>true) do
-          @d.insert(:name => 'def', :value => 2)
-          @db.rollback_on_exit(:savepoint=>true)
-          @db.transaction(:savepoint=>true) do
-            @db.rollback_on_exit(:savepoint=>true)
-            @d.insert(:name => 'ghi', :value => 3)
-          end
-        end
-      end
-      @d.select_order_map(:value).must_equal [1]
-    end
-
-    it "should support rollback_on_exit with :savepoint=>Integer" do
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.transaction(:savepoint=>true) do
-          @d.insert(:name => 'def', :value => 2)
-          @db.rollback_on_exit(:savepoint=>2)
-        end
-      end
-      @d.must_be_empty
-
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.transaction(:savepoint=>true) do
-          @d.insert(:name => 'def', :value => 2)
-          @db.rollback_on_exit(:savepoint=>3)
-        end
-      end
-      @d.must_be_empty
-
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.transaction(:savepoint=>true) do
-          @d.insert(:name => 'def', :value => 2)
-          @db.transaction(:savepoint=>true) do
-            @db.rollback_on_exit(:savepoint=>2)
-            @d.insert(:name => 'ghi', :value => 3)
-          end
-        end
-      end
-      @d.select_order_map(:value).must_equal [1]
-    end
-
-    it "should support rollback_on_exit with :savepoint=>Integer and :cancel" do
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.transaction(:savepoint=>true) do
-          @db.rollback_on_exit(:savepoint=>true)
-          @d.insert(:name => 'def', :value => 2)
-          @db.transaction(:savepoint=>true) do
-            @db.rollback_on_exit(:savepoint=>2, :cancel=>true)
-            @d.insert(:name => 'ghi', :value => 3)
-          end
-        end
-      end
-      @d.select_order_map(:value).must_equal [1, 2, 3]
-
-      @d.delete
-      @db.transaction do
-        @db.rollback_on_exit(:savepoint=>true)
-        @d.insert(:name => 'abc', :value => 1)
-        @db.transaction(:savepoint=>true) do
-          @db.rollback_on_exit(:savepoint=>true)
-          @d.insert(:name => 'def', :value => 2)
-          @db.transaction(:savepoint=>true) do
-            @db.rollback_on_exit(:savepoint=>3, :cancel=>true)
-            @d.insert(:name => 'ghi', :value => 3)
-          end
-        end
-      end
-      @d.select_order_map(:value).must_equal [1, 2, 3]
-
-      @d.delete
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.rollback_on_exit(:savepoint=>true)
-        @db.transaction(:savepoint=>true) do
-          @d.insert(:name => 'def', :value => 2)
-          @db.transaction(:savepoint=>true) do
-            @db.rollback_on_exit(:savepoint=>4, :cancel=>true)
-            @d.insert(:name => 'ghi', :value => 3)
-          end
-        end
-      end
-      @d.select_order_map(:value).must_equal [1, 2, 3]
-
-      @d.delete
-      @db.transaction do
-        @d.insert(:name => 'abc', :value => 1)
-        @db.transaction(:savepoint=>true) do
-          @db.rollback_on_exit(:savepoint=>2)
-          @d.insert(:name => 'def', :value => 2)
-          @db.transaction(:savepoint=>true) do
-            @db.rollback_on_exit(:savepoint=>2, :cancel=>true)
-            @d.insert(:name => 'ghi', :value => 3)
-          end
-        end
-      end
-      @d.must_be_empty
-    end
-
-    it "should handle table_exists? failures inside transactions" do
-      @db.transaction do
-        @d.insert(:name => '1')
-        @db.table_exists?(:asadf098asd9asd98sa).must_equal false
-        @d.insert(:name => '2')
-      end
-      @d.select_order_map(:name).must_equal %w'1 2'
-    end
-
-    it "should handle :rollback=>:always inside transactions" do
-      @db.transaction do
-        @db.transaction(:rollback=>:always) do
-          @d.insert(:name => 'abc', :value => 1)
-          2
-        end.must_equal 2
-      end
-      @d.select_order_map(:value).must_equal []
-    end
-
-    it "should handle table_exists? failures inside savepoints" do
-      @db.transaction do
-        @d.insert(:name => '1')
-        @db.transaction(:savepoint=>true) do
-          @d.insert(:name => '2')
-          @db.table_exists?(:asadf098asd9asd98sa).must_equal false
-          @d.insert(:name => '3')
-        end
-        @d.insert(:name => '4')
-      end
-      @d.select_order_map(:name).must_equal %w'1 2 3 4'
-    end
-
-    it "should support nested transactions through savepoints using the savepoint option" do
-      @db.transaction do
-        @d.insert(:name => '1')
-        @db.transaction(:savepoint=>true) do
-          @d.insert(:name => '2')
-          @db.transaction do
-            @d.insert(:name => '3')
-            raise Sequel::Rollback
-          end
-        end
-        @d.insert(:name => '4')
-        @db.transaction do
-          @d.insert(:name => '6')
-          @db.transaction(:savepoint=>true) do
-            @d.insert(:name => '7')
-            raise Sequel::Rollback
-          end
-        end
-        @d.insert(:name => '5')
-      end
-
-      @d.order(:name).map(:name).must_equal %w{1 4 5 6}
-    end
-
-    it "should support nested transactions through savepoints using the auto_savepoint option" do
-      @db.transaction(:auto_savepoint=>true) do
-        @d.insert(:name => '1')
-        @db.transaction do
-          @d.insert(:name => '2')
-          @db.transaction do
-            @d.insert(:name => '3')
-            raise Sequel::Rollback
-          end
-        end
-        @d.insert(:name => '4')
-        @db.transaction(:auto_savepoint=>true) do
-          @d.insert(:name => '6')
-          @db.transaction do
-            @d.insert(:name => '7')
-            raise Sequel::Rollback
-          end
-        end
-        @d.insert(:name => '5')
-      end
-
-      @d.order(:name).map(:name).must_equal %w{1 4 5 6}
-    end
-  end
-
-  it "should handle returning inside of the block by committing" do
-    def ret_commit
-      @db.transaction do
-        @db[:items].insert(:name => 'abc')
-        return
-      end
-    end
-
-    @d.count.must_equal 0
-    ret_commit
-    @d.count.must_equal 1
-    ret_commit
-    @d.count.must_equal 2
-    proc do
-      @db.transaction do
-        raise Interrupt, 'asdf'
-      end
-    end.must_raise(Interrupt)
-
-    @d.count.must_equal 2
-  end
-
-  if DB.supports_prepared_transactions?
-    it "should allow saving and destroying of model objects" do
-      c = Class.new(Sequel::Model(@d))
-      c.set_primary_key :name
-      c.unrestrict_primary_key
-      @db.transaction(:prepare=>'XYZ'){c.create(:name => '1'); c.create(:name => '2').destroy}
-      @db.commit_prepared_transaction('XYZ')
-      @d.select_order_map(:name).must_equal ['1']
-    end
-
-    it "should commit prepared transactions using commit_prepared_transaction" do
-      @db.transaction(:prepare=>'XYZ'){@d.insert(:name => '1')}
-      @db.commit_prepared_transaction('XYZ')
-      @d.select_order_map(:name).must_equal ['1']
-    end
-
-    it "should rollback prepared transactions using rollback_prepared_transaction" do
-      @db.transaction(:prepare=>'XYZ'){@d.insert(:name => '1')}
-      @db.rollback_prepared_transaction('XYZ')
-      @d.select_order_map(:name).must_equal []
-    end
-
-    if DB.supports_savepoints_in_prepared_transactions?
-      it "should support savepoints when using prepared transactions" do
-        @db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@d.insert(:name => '1')}}
-        @db.commit_prepared_transaction('XYZ')
-        @d.select_order_map(:name).must_equal ['1']
-      end
-    end
-  end
-
-  it "should support all transaction isolation levels" do
-    [:uncommitted, :committed, :repeatable, :serializable].each_with_index do |l, i|
-      @db.transaction(:isolation=>l){@d.insert(:name => 'abc', :value => 1)}
-      @d.count.must_equal i + 1
-    end
-  end
-
-  it "should support after_commit outside transactions" do
-    c = nil
-    @db.after_commit{c = 1}
-    c.must_equal 1
-  end
-
-  it "should support after_rollback outside transactions" do
-    c = nil
-    @db.after_rollback{c = 1}
-    c.must_be_nil
-  end
-
-  it "should support after_commit inside transactions" do
-    c = nil
-    @db.transaction{@db.after_commit{c = 1}; c.must_be_nil}
-    c.must_equal 1
-  end
-
-  it "should support after_rollback inside transactions" do
-    c = nil
-    @db.transaction{@db.after_rollback{c = 1}; c.must_be_nil}
-    c.must_be_nil
-  end
-
-  it "should not call after_commit if the transaction rolls back" do
-    c = nil
-    @db.transaction{@db.after_commit{c = 1}; c.must_be_nil; raise Sequel::Rollback}
-    c.must_be_nil
-  end
-
-  it "should call after_rollback if the transaction rolls back" do
-    c = nil
-    @db.transaction{@db.after_rollback{c = 1}; c.must_be_nil; raise Sequel::Rollback}
-    c.must_equal 1
-  end
-
-  it "should support multiple after_commit blocks inside transactions" do
-    c = []
-    @db.transaction{@db.after_commit{c << 1}; @db.after_commit{c << 2}; c.must_equal []}
-    c.must_equal [1, 2]
-  end
-
-  it "should support multiple after_rollback blocks inside transactions" do
-    c = []
-    @db.transaction{@db.after_rollback{c << 1}; @db.after_rollback{c << 2}; c.must_equal []; raise Sequel::Rollback}
-    c.must_equal [1, 2]
-  end
-
-  it "should support after_commit inside nested transactions" do
-    c = nil
-    @db.transaction{@db.transaction{@db.after_commit{c = 1}}; c.must_be_nil}
-    c.must_equal 1
-  end
-
-  it "should support after_rollback inside nested transactions" do
-    c = nil
-    @db.transaction{@db.transaction{@db.after_rollback{c = 1}}; c.must_be_nil; raise Sequel::Rollback}
-    c.must_equal 1
-  end
-
-  if DB.supports_savepoints?
-    it "should support after_commit inside savepoints" do
-      c = nil
-      @db.transaction{@db.transaction(:savepoint=>true){@db.after_commit{c = 1}}; c.must_be_nil}
-      c.must_equal 1
-    end
-
-    it "should support after_rollback inside savepoints" do
-      c = nil
-      @db.transaction{@db.transaction(:savepoint=>true){@db.after_rollback{c = 1}}; c.must_be_nil; raise Sequel::Rollback}
-      c.must_equal 1
-    end
-
-    it "should support after_commit inside savepoints with :savepoint_option" do
-      c = nil
-      @db.transaction{@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}; c.must_be_nil}
-      c.must_equal 1
-
-      c = nil
-      @db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}}; c.must_be_nil}
-      c.must_equal 1
-
-      c = nil
-      @db.transaction{@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_commit(:savepoint=>true){c = 1}}}
-      c.must_be_nil
-
-      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}}
-      c.must_be_nil
-
-      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}}}
-      c.must_be_nil
-    end
-
-    it "should support after_rollback inside savepoints with :savepoint_option" do
-      c = nil
-      @db.transaction{@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback(:savepoint=>true){c = 1}; c.must_be_nil}; c.must_equal 1}
-      c.must_equal 1
-
-      c = nil
-      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}
-      c.must_equal 1
-
-      c = nil
-      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback(:savepoint=>true){c = 1}; c.must_be_nil}; c.must_equal 1}
-      c.must_equal 1
-
-      c = nil
-      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}
-      c.must_equal 1
-
-      c = nil
-      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}}
-      c.must_equal 1
-
-      c = nil
-      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback(:savepoint=>true){c = 1}; c.must_be_nil}; c.must_equal 1}}
-      c.must_equal 1
-
-      c = nil
-      @db.transaction{@db.transaction(:savepoint=>true, :rollback=>:always){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}; c.must_equal 1}
-      c.must_equal 1
-    end
-  end
-
-  if DB.supports_prepared_transactions?
-    it "should raise an error if you attempt to use after_commit or after_rollback inside a prepared transaction" do
-      proc{@db.transaction(:prepare=>'XYZ'){@db.after_commit{}}}.must_raise(Sequel::Error)
-      proc{@db.transaction(:prepare=>'XYZ'){@db.after_rollback{}}}.must_raise(Sequel::Error)
-    end
-
-    if DB.supports_savepoints_in_prepared_transactions?
-      it "should raise an error if you attempt to use after_commit or after rollback inside a savepoint in a prepared transaction" do
-        proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_commit{}}}}.must_raise(Sequel::Error)
-        proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_rollback{}}}}.must_raise(Sequel::Error)
-      end
-    end
-  end
-end
-
-describe "Database transaction retrying" do
-  before(:all) do
-    @db = DB
-    @db.create_table!(:items, :engine=>'InnoDB'){String :a, :unique=>true, :null=>false}
-    @d = @db[:items]
-  end
-  before do
-    @d.delete
-  end
-  after(:all) do
-    @db.drop_table?(:items)
-  end
-
-  it "should be supported using the :retry_on option" do
-    @d.insert('b')
-    @d.insert('c')
-    s = 'a'
-    @db.transaction(:retry_on=>Sequel::ConstraintViolation) do
-      s = s.succ
-      @d.insert(s)
-    end
-    @d.select_order_map(:a).must_equal %w'b c d'
-  end
-
-  it "should limit number of retries via the :num_retries option" do
-    @d.insert('b')
-    @d.insert('c')
-    s = 'a'
-    lambda do
-      @db.transaction(:num_retries=>1, :retry_on=>Sequel::ConstraintViolation) do
-        s = s.succ
-        @d.insert(s)
-      end
-    end.must_raise(Sequel::UniqueConstraintViolation, Sequel::ConstraintViolation)
-    @d.select_order_map(:a).must_equal %w'b c'
-  end
-end
-