sequel 5.19.0 → 5.24.0

data/spec/extensions/pg_range_spec.rb

@@ -17,6 +17,7 @@ describe "pg_range extension" do
   end
 
   endless_range_support = RUBY_VERSION >= '2.6'
+  startless_range_support = RUBY_VERSION >= '2.7'
 
   it "should set up conversion procs correctly" do
     cp = @db.conversion_procs
@@ -52,8 +53,19 @@ describe "pg_range extension" do
 
   it "should literalize endless Range instances to strings correctly" do
     @db.literal(eval('1..')).must_equal "'[1,]'"
+    @db.literal(eval('1...')).must_equal "'[1,)'"
   end if endless_range_support
 
+  it "should literalize startless Range instances to strings correctly" do
+    @db.literal(eval('..1')).must_equal "'[,1]'"
+    @db.literal(eval('...1')).must_equal "'[,1)'"
+  end if startless_range_support
+
+  it "should literalize startless, endless Range instances to strings correctly" do
+    @db.literal(eval('nil..nil')).must_equal "'[,]'"
+    @db.literal(eval('nil...nil')).must_equal "'[,)'"
+  end if startless_range_support
+
   it "should literalize PGRange instances to strings correctly" do
     @db.literal(@R.new(1, 2)).must_equal "'[1,2]'"
     @db.literal(@R.new(true, false)).must_equal "'[true,false]'"
@@ -79,8 +91,19 @@ describe "pg_range extension" do
 
   it "should support using endless Range instances as bound variables" do
     @db.bound_variable_arg(eval('1..'), nil).must_equal "[1,]"
+    @db.bound_variable_arg(eval('1...'), nil).must_equal "[1,)"
   end if endless_range_support
 
+  it "should support using startless Range instances as bound variables" do
+    @db.bound_variable_arg(eval('..1'), nil).must_equal "[,1]"
+    @db.bound_variable_arg(eval('...1'), nil).must_equal "[,1)"
+  end if startless_range_support
+
+  it "should support using startless, endless Range instances as bound variables" do
+    @db.bound_variable_arg(eval('nil..nil'), nil).must_equal "[,]"
+    @db.bound_variable_arg(eval('nil...nil'), nil).must_equal "[,)"
+  end if startless_range_support
+
   it "should support using PGRange instances as bound variables" do
     @db.bound_variable_arg(@R.new(1, 2), nil).must_equal "[1,2]"
   end
@@ -406,12 +429,12 @@ describe "pg_range extension" do
       @R.new(nil, nil).wont_equal @R.new(nil, nil, :empty=>true)
     end
 
-    it "should only consider empty PGRanges equal if they have the same bounds" do
+    it "should only consider PGRanges equal if they have the same bounds" do
       @R.new(1, 2).must_equal @R.new(1, 2)
       @R.new(1, 2).wont_equal @R.new(1, 3)
     end
 
-    it "should only consider empty PGRanges equal if they have the same bound exclusions" do
+    it "should only consider PGRanges equal if they have the same bound exclusions" do
       @R.new(1, 2, :exclude_begin=>true).must_equal @R.new(1, 2, :exclude_begin=>true)
       @R.new(1, 2, :exclude_end=>true).must_equal @R.new(1, 2, :exclude_end=>true)
       @R.new(1, 2, :exclude_begin=>true).wont_equal @R.new(1, 2, :exclude_end=>true)
@@ -427,16 +450,39 @@ describe "pg_range extension" do
 
     it "should not consider a PGRange equal with a Range if it can't be expressed as a range" do
       @R.new(nil, nil).wont_be :==, (1..2)
+      if startless_range_support
+        @R.new(nil, nil, :exclude_begin=>true).wont_be :==, eval('nil..nil')
+      end
     end
 
     it "should consider PGRanges equal with a endless Range they represent" do
       @R.new(1, nil).must_be :==, eval('1..')
-    end if endless_range_support
-
-    it "should not consider a PGRange equal with a Range if it can't be expressed as a range" do
+      @R.new(1, nil, :exclude_end=>true).must_be :==, eval('1...')
+      @R.new(1, nil).wont_be :==, eval('1...')
+      @R.new(1, nil, :exclude_end=>true).wont_be :==, eval('1..')
       @R.new(1, nil).wont_be :==, eval('2..')
+      @R.new(1, nil, :exclude_end=>true).wont_be :==, eval('2...')
     end if endless_range_support
 
+    it "should consider PGRanges equal with a startless Range they represent" do
+      @R.new(nil, 1).must_be :==, eval('..1')
+      @R.new(nil, 1, :exclude_end=>true).must_be :==, eval('...1')
+      @R.new(nil, 1).wont_be :==, eval('...1')
+      @R.new(nil, 1, :exclude_end=>true).wont_be :==, eval('..1')
+      @R.new(nil, 1).wont_be :==, eval('..2')
+      @R.new(nil, 1, :exclude_end=>true).wont_be :==, eval('...2')
+    end if startless_range_support
+
+    it "should consider PGRanges equal with a startless, endless Range they represent" do
+      @R.new(nil, nil).must_be :==, eval('nil..nil')
+      @R.new(nil, nil, :exclude_end=>true).must_be :==, eval('nil...nil')
+      @R.new(nil, nil).wont_be :==, eval('nil...nil')
+      @R.new(nil, nil, :exclude_end=>true).wont_be :==, eval('nil..nil')
+      @R.new(nil, nil).wont_be :==, eval('nil..1')
+      @R.new(nil, nil).wont_be :==, eval('1..nil')
+      @R.new(1, nil).wont_be :==, eval('nil..nil')
+    end if startless_range_support
+
     it "should not consider a PGRange equal to other objects" do
       @R.new(nil, nil).wont_equal 1
     end
@@ -444,7 +490,6 @@ describe "pg_range extension" do
     it "should have #=== be true if given an equal PGRange" do
       @R.new(1, 2).must_be :===, @R.new(1, 2)
       @R.new(1, 2).wont_be :===, @R.new(1, 3)
-
     end
 
     it "should have #=== be true if it would be true for the Range represented by the PGRange" do
@@ -453,7 +498,7 @@ describe "pg_range extension" do
     end
 
     it "should have #=== be false if the PGRange cannot be represented by a Range" do
-      @R.new(nil, nil).wont_be :===, 1.5
+      @R.new(1, 2, :exclude_begin=>true).wont_be :===, 1.5
     end
 
     it "should have #empty? indicate whether the range is empty" do
@@ -471,7 +516,6 @@ describe "pg_range extension" do
     end
 
     it "should have #to_range raise an exception if the PGRange cannot be represented by a Range" do
-      proc{@R.new(nil, 1).to_range}.must_raise(Sequel::Error)
       proc{@R.new(0, 1, :exclude_begin=>true).to_range}.must_raise(Sequel::Error)
       proc{@R.empty.to_range}.must_raise(Sequel::Error)
     end
@@ -488,6 +532,22 @@ describe "pg_range extension" do
       proc{@R.new(1, nil).to_range}.must_raise(Sequel::Error)
     end unless endless_range_support
 
+    it "should have #to_range return the represented range for startless ranges" do
+      @R.new(nil, 1).to_range.must_be :==, eval('..1')
+    end if startless_range_support
+
+    it "should have #to_range raise an exception for startless ranges" do
+      proc{@R.new(nil, 1).to_range}.must_raise(Sequel::Error)
+    end unless startless_range_support
+
+    it "should have #to_range return the represented range for startless, endless ranges" do
+      @R.new(nil, nil).to_range.must_be :==, eval('nil..nil')
+    end if startless_range_support
+
+    it "should have #to_range raise an exception for startless, endless ranges" do
+      proc{@R.new(nil, nil).to_range}.must_raise(Sequel::Error)
+    end unless startless_range_support
+
     it "should have #to_range cache the returned value" do
       @r1.to_range.must_be_same_as(@r1.to_range)
     end
@@ -507,7 +567,6 @@ describe "pg_range extension" do
     end
 
     it "should have #valid_ruby_range? return false if the PGRange cannot be represented as a Range" do
-      @R.new(nil, 1).valid_ruby_range?.must_equal false
       @R.new(0, 1, :exclude_begin=>true).valid_ruby_range?.must_equal false
       @R.empty.valid_ruby_range?.must_equal false
     end
@@ -515,5 +574,13 @@ describe "pg_range extension" do
    it "should have #valid_ruby_range return #{endless_range_support} for endless ranges" do
       @R.new(1, nil).valid_ruby_range?.must_equal(endless_range_support)
     end
+
+   it "should have #valid_ruby_range return #{startless_range_support} for endless ranges" do
+      @R.new(nil, 1).valid_ruby_range?.must_equal(startless_range_support)
+    end
+
+   it "should have #valid_ruby_range return #{startless_range_support} for startless, endless ranges" do
+      @R.new(nil, nil).valid_ruby_range?.must_equal(startless_range_support)
+    end
   end
 end

data/spec/extensions/rcte_tree_spec.rb

@@ -254,6 +254,12 @@ describe Sequel::Model, "rcte_tree" do
     @db.sqls.must_equal ["SELECT * FROM nodes",
       'WITH t AS (SELECT parent_id AS x_root_x, nodes.* FROM nodes WHERE ((parent_id IN (2, 6, 7)) AND (i = 1)) UNION ALL SELECT t.x_root_x, nodes.* FROM nodes INNER JOIN t ON (t.id = nodes.parent_id) WHERE (i = 1)) SELECT * FROM t AS nodes WHERE (i = 1)']
   end
+
+  it "should disallow eager graphing of ancestors and descendants" do
+    @c.plugin :rcte_tree
+    proc{@c.eager_graph(:ancestors)}.must_raise Sequel::Error
+    proc{@c.eager_graph(:descendants)}.must_raise Sequel::Error
+  end
 end
 
 describe Sequel::Model, "rcte_tree with composite keys" do

data/spec/extensions/s_spec.rb

@@ -29,7 +29,7 @@ describe "s extension as refinement" do
 end
 
 
-if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') # || (RUBY_VERSION >= '2.3.0' && RUBY_ENGINE == 'jruby')
+if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') || (RUBY_ENGINE == 'jruby' && (JRUBY_VERSION >= '9.3' || (JRUBY_VERSION.match(/\A9\.2\.(\d+)/) && $1.to_i >= 7)))
 using Sequel::S
 
 describe "s extension as refinement" do

data/spec/extensions/schema_dumper_spec.rb

@@ -800,14 +800,16 @@ END_MIG
   it "should convert mysql types to ruby types" do
     def @d.schema(t, *o)
       i = 0
-      ['double(15,2)', 'double(7,1) unsigned'].map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
+      ['float unsigned', 'double(15,2)', 'double(7,1) unsigned'].map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
     end
     @d.dump_table_schema(:x).must_equal((<<END_MIG).chomp)
 create_table(:x) do
   Float :c1
   Float :c2
+  Float :c3
   
-  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c2), 0)
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c1), 0)
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c3), 0)
 end
 END_MIG
   end

data/spec/extensions/server_block_spec.rb

@@ -95,3 +95,41 @@ describe "Database#with_server multi threaded" do
   end
 end
 
+describe "Database#with_server with invalid servers" do
+  def sqls(server)
+    @db.with_server(server) do
+      @db[:t].all
+      @db[:t].insert
+      @db[:t].update(:a=>1)
+      @db[:t].delete
+    end
+    @db.sqls
+  end
+
+  it "when single threaded and no servers_hash" do
+    @db = Sequel.mock(:single_threaded=>true, :servers=>{:a=>{}}).extension(:server_block)
+    sqls(:a).must_equal ["SELECT * FROM t -- a", "INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
+    sqls(:c).must_equal ["SELECT * FROM t", "INSERT INTO t DEFAULT VALUES", "UPDATE t SET a = 1", "DELETE FROM t"]
+  end
+
+  it "when multi-threaded and no servers_hash" do
+    @db = Sequel.mock(:servers=>{:a=>{}}).extension(:server_block)
+    sqls(:a).must_equal ["SELECT * FROM t -- a", "INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
+    sqls(:c).must_equal ["SELECT * FROM t", "INSERT INTO t DEFAULT VALUES", "UPDATE t SET a = 1", "DELETE FROM t"]
+  end
+
+  it "when single threaded and servers_hash" do
+    @db = Sequel.mock(:single_threaded=>true, :servers=>{:a=>{}, :b=>{}}, :servers_hash=>Hash.new{|_,k| raise}.merge!(:c=>:b)).extension(:server_block)
+    sqls(:a).must_equal ["SELECT * FROM t -- a", "INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
+    sqls(:c).must_equal ["SELECT * FROM t -- b", "INSERT INTO t DEFAULT VALUES -- b", "UPDATE t SET a = 1 -- b", "DELETE FROM t -- b"]
+    proc{sqls(:d)}.must_raise(RuntimeError)
+  end
+
+  it "when multi-threaded and servers_hash" do
+    @db = Sequel.mock(:servers=>{:a=>{}, :b=>{}}, :servers_hash=>Hash.new{|_,k| raise}.merge!(:c=>:b)).extension(:server_block)
+    sqls(:a).must_equal ["SELECT * FROM t -- a", "INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
+    sqls(:c).must_equal ["SELECT * FROM t -- b", "INSERT INTO t DEFAULT VALUES -- b", "UPDATE t SET a = 1 -- b", "DELETE FROM t -- b"]
+    proc{sqls(:d)}.must_raise(RuntimeError)
+  end
+end
+

data/spec/extensions/spec_helper.rb

@@ -16,6 +16,11 @@ require_relative "../../lib/sequel"
 
 require_relative '../deprecation_helper'
 
+if ENV['SEQUEL_TZINFO_VERSION']
+  # Allow forcing specific TZInfo versions, useful when testing
+  gem 'tzinfo', ENV['SEQUEL_TZINFO_VERSION']
+end
+
 begin
   # Attempt to load ActiveSupport blank extension and inflector first, so Sequel
   # can override them.
@@ -26,7 +31,9 @@ rescue LoadError
   nil
 end
 
-Sequel.extension :core_refinements if RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby'
+if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') || (RUBY_ENGINE == 'jruby' && (JRUBY_VERSION >= '9.3' || (JRUBY_VERSION.match(/\A9\.2\.(\d+)/) && $1.to_i >= 7)))
+  Sequel.extension :core_refinements
+end
 
 class << Sequel::Model
   attr_writer :db_schema

data/spec/extensions/static_cache_cache_spec.rb

@@ -0,0 +1,35 @@
+require_relative "spec_helper"
+
+describe "static_cache_cache plugin" do
+  before do
+    @db = Sequel.mock
+    @db.fetch = [{:id=>1, :name=>'A'}, {:id=>2, :name=>'B'}]
+    @c = Class.new(Sequel::Model(@db[:t]))
+    def @c.name; 'Foo' end
+    @c.columns :id, :name
+    @file = "spec/files/static_cache_cache-spec-#{$$}.cache"
+  end
+  after do
+    File.delete(@file) if File.file?(@file)
+  end
+
+  it "should allow dumping and loading static cache rows from a cache file" do
+    @c.plugin :static_cache_cache, @file
+    @db.sqls
+    @c.plugin :static_cache
+    @db.sqls.must_equal ['SELECT * FROM t']
+    @c.all.must_equal [@c.load(:id=>1, :name=>'A'), @c.load(:id=>2, :name=>'B')]
+
+    @c.dump_static_cache_cache
+
+    @db.fetch = []
+    c = Class.new(Sequel::Model(@db[:t]))
+    def c.name; 'Foo' end
+    c.columns :id, :name
+    @c.plugin :static_cache_cache, @file
+    @db.sqls
+    @c.plugin :static_cache
+    @db.sqls.must_be_empty
+    @c.all.must_equal [@c.load(:id=>1, :name=>'A'), @c.load(:id=>2, :name=>'B')]
+  end
+end

data/spec/integration/dataset_test.rb

@@ -957,7 +957,7 @@ if DB.dataset.supports_window_functions?
           must_equal [{:sum=>110, :id=>1}, {:sum=>1100, :id=>2}, {:sum=>11000, :id=>3}, {:sum=>110000, :id=>4}, {:sum=>100000, :id=>5}, {:sum=>nil, :id=>6}]
       end
 
-      cspecify "should give correct results for aggregate window functions with offsets for RANGES", :mssql, :sqlite, [proc{DB.server_version < 110000}, :postgres] do
+      cspecify "should give correct results for aggregate window functions with offsets for RANGES", :mssql, [proc{DB.sqlite_version < 32800}, :sqlite], [proc{DB.server_version < 110000}, :postgres] do
         @ds.select(:id){sum(:amount).over(:order=>:group_id, :frame=>{:type=>:range, :start=>1}).as(:sum)}.all.
           must_equal [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
         @ds.select(:id){sum(:amount).over(:order=>:group_id, :frame=>{:type=>:range, :start=>0, :end=>1}).as(:sum)}.all.
@@ -1109,6 +1109,12 @@ describe "Sequel::Dataset#import and #multi_insert :return=>:primary_key " do
     @ds.order(:id).map([:id, :i]).must_equal [[1, 10], [2, 20], [3, 30], [4, 40], [5, 50], [6, 60]]
   end
 
+  it "should handle dataset with row_proc" do
+    ds = @ds.with_row_proc(lambda{|h| Object.new})
+    ds.multi_insert([{:i=>10}, {:i=>20}, {:i=>30}], :return=>:primary_key).must_equal [1, 2, 3]
+    ds.import([:i], [[40], [50], [60]], :return=>:primary_key).must_equal [4, 5, 6]
+  end
+  
   it "should return primary key values when :slice is used" do
     @ds.multi_insert([{:i=>10}, {:i=>20}, {:i=>30}], :return=>:primary_key, :slice=>2).must_equal [1, 2, 3]
     @ds.import([:i], [[40], [50], [60]], :return=>:primary_key, :slice=>2).must_equal [4, 5, 6]
@@ -1545,15 +1551,25 @@ describe "Sequel::Dataset DSL support" do
     @ds.exclude(:a=>[20, 10]).all.must_equal []
   end
   
-  it "should work with ranges as hash values" do
+  it "should work with endless ranges as hash values" do
     @ds.insert(20, 10)
-    @ds.filter(:a=>(10..30)).all.must_equal [{:a=>20, :b=>10}]
-    @ds.filter(:a=>(25..30)).all.must_equal []
-    @ds.filter(:a=>(10..15)).all.must_equal []
-    @ds.exclude(:a=>(10..30)).all.must_equal []
-    @ds.exclude(:a=>(25..30)).all.must_equal [{:a=>20, :b=>10}]
-    @ds.exclude(:a=>(10..15)).all.must_equal [{:a=>20, :b=>10}]
-  end
+    @ds.filter(:a=>eval('30..')).all.must_equal []
+    @ds.filter(:a=>eval('20...')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('20..')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('10..')).all.must_equal [{:a=>20, :b=>10}]
+  end if RUBY_VERSION >= '2.6'
+  
+  it "should work with startless ranges as hash values" do
+    @ds.insert(20, 10)
+    @ds.filter(:a=>eval('..30')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('...30')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('..20')).all.must_equal [{:a=>20, :b=>10}]
+    @ds.filter(:a=>eval('...20')).all.must_equal []
+    @ds.filter(:a=>eval('..10')).all.must_equal []
+    @ds.filter(:a=>eval('...10')).all.must_equal []
+
+    @ds.filter(:a=>eval('nil..nil')).all.must_equal [{:a=>20, :b=>10}]
+  end if RUBY_VERSION >= '2.7'
   
   it "should work with CASE statements" do
     @ds.insert(20, 10)

data/spec/integration/plugin_test.rb

@@ -30,6 +30,7 @@ describe "Class Table Inheritance Plugin" do
     end 
     class ::Manager < Employee
       one_to_many :staff_members, :class=>:Staff
+      one_to_one :first_staff_member, :clone=>:staff_members, :order=>:id
     end 
     class ::Executive < Manager
     end 
@@ -150,6 +151,8 @@ describe "Class Table Inheritance Plugin" do
     m = Staff.first.manager
     m.must_equal Manager[@i4]
     m.must_be_kind_of(Executive)
+    Staff.first.update(:manager => Manager[@i3])
+    Staff.first.manager.must_equal Manager[@i3]
   end
   
   it "should handle eagerly loading many_to_one relationships" do
@@ -164,6 +167,18 @@ describe "Class Table Inheritance Plugin" do
   
   it "should handle one_to_many relationships" do
     Executive.first(:name=>'Ex').staff_members.must_equal [Staff[@i2]]
+    i6 = @db[:employees].insert(:name=>'S2', :kind=>'Staff')
+    @db[:staff].insert(:id=>i6, :manager_id=>@i4)
+    Executive.first(:name=>'Ex').add_staff_member(i6)
+    Executive.first(:name=>'Ex').staff_members{|ds| ds.order(:id)}.must_equal [Staff[@i2], Staff[i6]]
+  end
+  
+  it "should handle one_to_many relationships" do
+    Executive.first(:name=>'Ex').first_staff_member.must_equal Staff[@i2]
+    i6 = @db[:employees].insert(:name=>'S2', :kind=>'Staff')
+    @db[:staff].insert(:id=>i6, :manager_id=>@i4)
+    Executive.first(:name=>'Ex').first_staff_member = Staff[i6]
+    Executive.first(:name=>'Ex').staff_members.must_equal [Staff[i6]]
   end
   
   it "should handle eagerly loading one_to_many relationships" do
@@ -2379,3 +2394,30 @@ describe "string_agg extension" do
     @ds.select_group(:id).select_append(Sequel.string_agg(:s).order(:s).distinct.as(:v)).map([:id, :v]).must_equal [[1, 'a,b,c'], [2, 'aa,bb']]
   end
 end
+
+describe "insert_conflict plugin" do
+  before(:all) do
+    @db = DB
+    @db.create_table!(:ic_test) do
+      primary_key :id
+      String :s, :unique=>true
+      Integer :o
+    end
+    @model = Class.new(Sequel::Model)
+    @model.set_dataset @db[:ic_test]
+    @model.plugin :insert_conflict
+  end
+  after(:all) do
+    @db.drop_table?(:ic_test)
+  end
+
+  it "should allow Model#insert_conflict to work" do
+    ic_opts = {:target=>:s, :update => {:o => Sequel[:excluded][:o]}}
+    @model.new(:s=>'A', :o=>1).insert_conflict(ic_opts).save
+    @model.select_order_map([:s, :o]).must_equal [['A', 1]]
+    @model.new(:s=>'A', :o=>2).insert_conflict(ic_opts).save
+    @model.select_order_map([:s, :o]).must_equal [['A', 2]]
+    @model.new(:s=>'B', :o=>3).insert_conflict(ic_opts).save
+    @model.select_order_map([:s, :o]).must_equal [['A', 2], ['B', 3]]
+  end
+end if (DB.database_type == :postgres && DB.server_version >= 90500) || (DB.database_type == :sqlite && DB.sqlite_version >= 32400)

data/spec/integration/schema_test.rb

@@ -750,10 +750,15 @@ describe "Database schema modifiers" do
     @db.create_table!(:items) do
       primary_key :id
       Integer :i, :default=>20
+      Integer :j, :default=>10
+      String :s, :default=>'a'
     end
-    @ds.insert(:i=>10)
+    @ds.insert(:i=>10, :j=>20, :s=>'b')
     @db.drop_column(:items, :i)
-    @db.schema(:items, :reload=>true).map{|x| x.first}.must_equal [:id]
+    @db.schema(:items, :reload=>true).map{|x| x.first}.must_equal [:id, :j, :s]
+    @ds.first.must_equal(:id=>1, :j=>20, :s=>'b')
+    @ds.insert
+    @ds.first(:id=>2).must_equal(:id=>2, :j=>10, :s=>'a')
   end
 
   it "should remove foreign key columns from tables correctly" do