sequel 4.36.0 → 5.61.0

data/spec/integration/spec_helper.rb

@@ -1,56 +0,0 @@
-require 'rubygems'
-require 'logger'
-
-if ENV['COVERAGE']
-  require File.join(File.dirname(File.expand_path(__FILE__)), "../sequel_coverage")
-  SimpleCov.sequel_coverage(:group=>%r{lib/sequel/adapters})
-end
-
-unless Object.const_defined?('Sequel')
-  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel'
-end
-begin
-  require File.join(File.dirname(File.dirname(__FILE__)), 'spec_config.rb') unless defined?(DB)
-rescue LoadError
-end
-Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_(spec|test)\.rb/}
-
-Sequel::Database.extension :columns_introspection if ENV['SEQUEL_COLUMNS_INTROSPECTION']
-Sequel::Model.cache_associations = false if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']
-Sequel::Model.use_transactions = false
-Sequel.cache_anonymous_models = false
-
-require './spec/guards_helper'
-
-unless defined?(DB)
-  DB = Sequel.connect(ENV['SEQUEL_INTEGRATION_URL'])
-end
-
-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
-
-if ENV['SEQUEL_NO_AUTO_LITERAL_STRINGS']
-  DB.extension :no_auto_literal_strings
-end
-
-if ENV['SEQUEL_ERROR_SQL']
-  DB.extension :error_sql
-end
-
-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

data/spec/integration/timezone_test.rb

@@ -1,86 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
-
-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], [:do, :mysql], [:do, :postgres], [: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], [:do, :mysql], [:do, :postgres], [: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", [:do, :mysql], [:do, :postgres], [: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", [:do, :postgres], [: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

data/spec/integration/transaction_test.rb

@@ -1,406 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
-
-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 << {: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 << {:name => 'abc', :value => 1}
-        raise Interrupt, 'asdf'
-      end
-    end.must_raise(Interrupt)
-
-    @db.transaction do
-      @d << {:name => 'abc', :value => 1}
-      raise Sequel::Rollback
-    end.must_equal nil
-
-    proc do
-      @db.transaction(:rollback=>:reraise) do
-        @d << {:name => 'abc', :value => 1}
-        raise Sequel::Rollback
-      end
-    end.must_raise(Sequel::Rollback)
-
-    @db.transaction(:rollback=>:always) do
-      @d << {: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 << {:name => 'abc', :value => 1}
-      end 
-    end 
-    @d.count.must_equal 1
-
-    @d.delete
-    @db.transaction do
-      @d << {:name => 'abc', :value => 1}
-      @db.transaction do
-        raise Sequel::Rollback
-      end 
-    end
-    @d.count.must_equal 0
-
-    proc {@db.transaction do
-      @d << {:name => 'abc', :value => 1}
-      @db.transaction do
-        raise Interrupt, 'asdf'
-      end 
-    end}.must_raise(Interrupt)
-    @d.count.must_equal 0
-  end 
-  
-  if DB.supports_savepoints?
-    it "should handle table_exists? failures inside transactions" do
-      @db.transaction do
-        @d << {:name => '1'}
-        @db.table_exists?(:asadf098asd9asd98sa).must_equal false
-        @d << {: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 << {: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 << {:name => '1'}
-        @db.transaction(:savepoint=>true) do
-          @d << {:name => '2'}
-          @db.table_exists?(:asadf098asd9asd98sa).must_equal false
-          @d << {:name => '3'}
-        end
-        @d << {: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 << {:name => '1'}
-        @db.transaction(:savepoint=>true) do
-          @d << {:name => '2'}
-          @db.transaction do
-            @d << {:name => '3'}
-            raise Sequel::Rollback
-          end
-        end
-        @d << {:name => '4'}
-        @db.transaction do
-          @d << {:name => '6'}
-          @db.transaction(:savepoint=>true) do
-            @d << {:name => '7'}
-            raise Sequel::Rollback
-          end
-        end
-        @d << {: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 << {:name => '1'}
-        @db.transaction do
-          @d << {:name => '2'}
-          @db.transaction do
-            @d << {:name => '3'}
-            raise Sequel::Rollback
-          end
-        end
-        @d << {:name => '4'}
-        @db.transaction(:auto_savepoint=>true) do
-          @d << {:name => '6'}
-          @db.transaction do
-            @d << {:name => '7'}
-            raise Sequel::Rollback
-          end
-        end
-        @d << {: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 @db.ret_commit
-      transaction do
-        self[:items] << {:name => 'abc'}
-        return
-      end
-    end
-
-    @d.count.must_equal 0
-    @db.ret_commit
-    @d.count.must_equal 1
-    @db.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
-      c.use_after_commit_rollback = false
-      @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 << {: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 << {: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 << {: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 << {: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_equal nil
-  end
-
-  it "should support after_commit inside transactions" do
-    c = nil
-    @db.transaction{@db.after_commit{c = 1}; c.must_equal 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_equal nil}
-    c.must_equal 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_equal nil; raise Sequel::Rollback}
-    c.must_equal nil
-  end
-
-  it "should call after_rollback if the transaction rolls back" do
-    c = nil
-    @db.transaction{@db.after_rollback{c = 1}; c.must_equal 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_equal 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_equal 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_equal 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_equal nil; raise Sequel::Rollback}
-      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
-
-if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or (RUBY_ENGINE == 'rbx' && !Sequel.guarded?([:do, :sqlite], [:tinytds, :mssql]))) and RUBY_VERSION < '1.9'
-  describe "Database transactions and Thread#kill" do
-    before do
-      @db = DB
-      @db.create_table!(:items, :engine=>'InnoDB'){String :name; Integer :value}
-      @d = @db[:items]
-    end
-    after do
-      @db.drop_table?(:items)
-    end
-
-    it "should handle transactions inside threads" do
-      q = Queue.new
-      q1 = Queue.new
-      t = Thread.new do
-        @db.transaction do
-          @d << {:name => 'abc', :value => 1}
-          q1.push nil
-          q.pop
-          @d << {:name => 'def', :value => 2}
-        end
-      end
-      q1.pop
-      t.kill
-      @d.count.must_equal 0
-    end
-
-    if DB.supports_savepoints?
-      it "should handle transactions with savepoints inside threads" do
-        q = Queue.new
-        q1 = Queue.new
-        t = Thread.new do
-          @db.transaction do
-            @d << {:name => 'abc', :value => 1}
-            @db.transaction(:savepoint=>true) do
-              @d << {:name => 'def', :value => 2}
-              q1.push nil
-              q.pop
-              @d << {:name => 'ghi', :value => 3}
-            end
-            @d << {:name => 'jkl', :value => 4}
-          end
-        end
-        q1.pop
-        t.kill
-        @d.count.must_equal 0
-      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
-
-  cspecify "should be supported using the :retry_on option", [:db2] 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
-
-  cspecify "should limit number of retries via the :num_retries option", [:db2] 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
-

data/spec/integration/type_test.rb

@@ -1,133 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
-
-describe "Supported types" do
-  def create_items_table_with_column(name, type, opts={})
-    DB.create_table!(:items){column name, type, opts}
-    DB[:items]
-  end
-
-  after(:all) do
-    DB.drop_table?(:items)
-  end
-
-  it "should support casting correctly" do
-    ds = create_items_table_with_column(:number, Integer)
-    ds.insert(:number => 1)
-    ds.select(Sequel.cast(:number, String).as(:n)).map(:n).must_equal %w'1'
-    ds = create_items_table_with_column(:name, String)
-    ds.insert(:name=> '1')
-    ds.select(Sequel.cast(:name, Integer).as(:n)).map(:n).must_equal [1]
-  end
-
-  it "should support NULL correctly" do
-    ds = create_items_table_with_column(:number, Integer)
-    ds.insert(:number => nil)
-    ds.all.must_equal [{:number=>nil}]
-  end
-
-  it "should support generic integer type" do
-    ds = create_items_table_with_column(:number, Integer)
-    ds.insert(:number => 2)
-    ds.all.must_equal [{:number=>2}]
-  end
-  
-  it "should support generic fixnum type" do
-    ds = create_items_table_with_column(:number, Fixnum)
-    ds.insert(:number => 2)
-    ds.all.must_equal [{:number=>2}]
-  end
-  
-  it "should support generic bignum type" do
-    ds = create_items_table_with_column(:number, :Bignum)
-    ds.insert(:number => 2**34)
-    ds.all.must_equal [{:number=>2**34}]
-  end
-  
-  cspecify "should support generic float type", [:swift, :sqlite] do
-    ds = create_items_table_with_column(:number, Float)
-    ds.insert(:number => 2.1)
-    ds.all.must_equal [{:number=>2.1}]
-  end
-  
-  cspecify "should support generic numeric type", [:odbc, :mssql], [:swift, :sqlite] do
-    ds = create_items_table_with_column(:number, Numeric, :size=>[15, 10])
-    ds.insert(:number => BigDecimal.new('2.123456789'))
-    ds.all.must_equal [{:number=>BigDecimal.new('2.123456789')}]
-    ds = create_items_table_with_column(:number, BigDecimal, :size=>[15, 10])
-    ds.insert(:number => BigDecimal.new('2.123456789'))
-    ds.all.must_equal [{:number=>BigDecimal.new('2.123456789')}]
-  end
-
-  it "should support generic string type" do
-    ds = create_items_table_with_column(:name, String)
-    ds.insert(:name => 'Test User')
-    ds.all.must_equal [{:name=>'Test User'}]
-  end
-  
-  it "should support generic text type" do
-    ds = create_items_table_with_column(:name, String, :text=>true)
-    ds.insert(:name => 'Test User'*100)
-    ds.all.must_equal [{:name=>'Test User'*100}]
-
-    ds.update(:name=>ds.get(:name))
-    ds.all.must_equal [{:name=>'Test User'*100}]
-  end
-  
-  cspecify "should support generic date type", [:do, :sqlite], [:jdbc, :sqlite], [:tinytds], [:jdbc, :mssql], :oracle do
-    ds = create_items_table_with_column(:dat, Date)
-    d = Date.today
-    ds.insert(:dat => d)
-    ds.first[:dat].must_be_kind_of(Date)
-    ds.first[:dat].to_s.must_equal d.to_s
-  end
-  
-  cspecify "should support generic time type", [:do], [:swift], [:odbc], [:jdbc, :mssql], [:jdbc, :sqlite], [:mysql2], [:tinytds], :oracle do
-    ds = create_items_table_with_column(:tim, Time, :only_time=>true)
-    t = Sequel::SQLTime.now
-    ds.insert(:tim => t)
-    v = ds.first[:tim]
-    ds.literal(v).must_equal ds.literal(t)
-    v.must_be_kind_of(Sequel::SQLTime)
-    ds.delete
-    ds.insert(:tim => v)
-    v2 = ds.first[:tim]
-    ds.literal(v2).must_equal ds.literal(t)
-    v2.must_be_kind_of(Sequel::SQLTime)
-  end
-  
-  cspecify "should support generic datetime type", [:do, :sqlite], [:jdbc, :sqlite] do
-    ds = create_items_table_with_column(:tim, DateTime)
-    t = DateTime.now
-    ds.insert(:tim => t)
-    ds.first[:tim].strftime('%Y%m%d%H%M%S').must_equal t.strftime('%Y%m%d%H%M%S')
-    ds = create_items_table_with_column(:tim, Time)
-    t = Time.now
-    ds.insert(:tim => t)
-    ds.first[:tim].strftime('%Y%m%d%H%M%S').must_equal t.strftime('%Y%m%d%H%M%S')
-  end
-  
-  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:tinytds] do
-    ds = create_items_table_with_column(:name, File)
-    ds.insert(:name =>Sequel.blob("a\0"*300))
-    ds.all.must_equal [{:name=>Sequel.blob("a\0"*300)}]
-    ds.first[:name].must_be_kind_of(::Sequel::SQL::Blob)
-  end
-  
-  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
-    ds = create_items_table_with_column(:number, TrueClass)
-    ds.insert(:number => true)
-    ds.all.must_equal [{:number=>true}]
-    ds = create_items_table_with_column(:number, FalseClass)
-    ds.insert(:number => true)
-    ds.all.must_equal [{:number=>true}]
-  end
-  
-  cspecify "should support generic boolean type with defaults", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
-    ds = create_items_table_with_column(:number, TrueClass, :default=>true)
-    ds.insert
-    ds.all.must_equal [{:number=>true}]
-    ds = create_items_table_with_column(:number, FalseClass, :default=>false)
-    ds.insert
-    ds.all.must_equal [{:number=>false}]
-  end
-end