sequel 4.41.0 → 4.42.0

data/spec/extensions/composition_spec.rb

@@ -123,8 +123,10 @@ describe "Composition plugin" do
   end
 
   it "should not clear compositions cache when saving with insert_select" do
-    def (@c.instance_dataset).supports_insert_select?() true end
-    def (@c.instance_dataset).insert_select(*) {:id=>1} end
+    @c.dataset = @c.dataset.with_extend do
+      def supports_insert_select?; true end
+      def insert_select(*) {:id=>1} end
+    end
     @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
     @c.create(:date=>Date.new(3, 4, 5)).compositions.must_equal(:date=>Date.new(3, 4, 5))
   end
@@ -201,7 +203,7 @@ describe "Composition plugin" do
 
   it ":mapping option :composer should return nil if all values are nil" do
     @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.new.date.must_equal nil
+    @c.new.date.must_be_nil
   end
 
   it ":mapping option :decomposer should set all related fields to nil if nil" do

data/spec/extensions/constraint_validations_plugin_spec.rb

@@ -19,9 +19,9 @@ describe "Sequel::Plugins::ConstraintValidations" do
     @db = Sequel.mock
     set_fetch({})
     @ds = @db[:items]
-    @ds.instance_variable_set(:@columns, [:name])
+    @ds.send(:columns=, [:name])
     @ds2 = Sequel.mock[:items2]
-    @ds2.instance_variable_set(:@columns, [:name])
+    @ds2.send(:columns=, [:name])
   end
 
   it "should load the validation_helpers plugin into the class" do
@@ -234,7 +234,7 @@ describe "Sequel::Plugins::ConstraintValidations" do
     c.plugin :constraint_validations, :validation_options=>{:unique=>{:message=>'is bad'}}
     c.constraint_validations.must_equal [[:validates_unique, [:name], {:message=>'is bad'}]]
     c.constraint_validation_reflections.must_equal(:name=>[[:unique, {:message=>'is bad'}]])
-    c.dataset._fetch = {:count=>1}
+    c.dataset = c.dataset.with_fetch(:count=>1)
     o = c.new(:name=>'a')
     o.valid?.must_equal false
     o.errors.full_messages.must_equal ['name is bad']
@@ -245,7 +245,7 @@ describe "Sequel::Plugins::ConstraintValidations" do
     c.plugin :constraint_validations, :validation_options=>{:unique=>{:message=>'is bad'}}
     c.constraint_validations.must_equal [[:validates_unique, [:name], {:message=>'is bad', :allow_nil=>true}]]
     c.constraint_validation_reflections.must_equal(:name=>[[:unique, {:message=>'is bad', :allow_nil=>true}]])
-    c.dataset._fetch = {:count=>1}
+    c.dataset = c.dataset.with_fetch(:count=>1)
     o = c.new(:name=>'a')
     o.valid?.must_equal false
     o.errors.full_messages.must_equal ['name is bad']
@@ -258,7 +258,7 @@ describe "Sequel::Plugins::ConstraintValidations" do
     sc.plugin :constraint_validations, :validation_options=>{:unique=>{:allow_missing=>true, :allow_nil=>false}}
     sc.constraint_validations.must_equal [[:validates_unique, [:name], {:message=>'is bad', :allow_missing=>true, :allow_nil=>false}]]
     sc.constraint_validation_reflections.must_equal(:name=>[[:unique, {:message=>'is bad', :allow_missing=>true, :allow_nil=>false}]])
-    sc.dataset._fetch = {:count=>1}
+    sc.dataset = sc.dataset.with_fetch(:count=>1)
     o = sc.new(:name=>'a')
     o.valid?.must_equal false
     o.errors.full_messages.must_equal ['name is bad']

data/spec/extensions/constraint_validations_spec.rb

@@ -2,8 +2,8 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "constraint_validations extension" do
   def parse_insert(s)
-    m = /\AINSERT INTO sequel_constraint_validations \((.*)\) VALUES \((.*)\)\z/.match(s)
-    Hash[*m[1].split(', ').map{|v| v.to_sym}.zip(m[2].split(', ').map{|v| parse_insert_value(v)}).reject{|k, v| v.nil?}.flatten]
+    m = /\AINSERT INTO "?sequel_constraint_validations"? \("?(.*)"?\) VALUES \((.*)\)\z/.match(s)
+    Hash[*m[1].split(/"?, "?/).map{|v| v.to_sym}.zip(m[2].split(/"?, "?/).map{|v| parse_insert_value(v)}).reject{|k, v| v.nil?}.flatten]
   end
 
   def parse_insert_value(s)
@@ -130,13 +130,17 @@ describe "constraint_validations extension" do
 
   it "should handle presence validation on Oracle with IS NOT NULL instead of != ''" do
     @db = Sequel.mock(:host=>'oracle')
+    @db.extend_datasets do
+      def quote_identifiers?; false end
+      def input_identifier(v) v.to_s end
+    end
     @db.extension(:constraint_validations)
     @db.create_table(:foo){String :name; validate{presence :name}}
     sqls = @db.sqls
-    s = sqls.slice!(1)
-    m = /\AINSERT INTO sequel_constraint_validations \((.*)\) SELECT (.*) FROM DUAL\z/.match(s)
-    Hash[*m[1].split(', ').map{|v| v.to_sym}.zip(m[2].split(', ').map{|v| parse_insert_value(v)}).reject{|k, v| v.nil?}.flatten].must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo")
-    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) IS NOT NULL)))"]
+    s = sqls.slice!(1).upcase
+    m = /\AINSERT INTO sequel_constraint_validations \((.*)\) SELECT (.*) FROM DUAL\z/i.match(s)
+    Hash[*m[1].split(', ').map{|v| v.downcase.to_sym}.zip(m[2].split(', ').map{|v| parse_insert_value(v.downcase.gsub('null', 'NULL'))}).reject{|k, v| v.nil?}.flatten].must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo")
+    sqls.must_equal ["BEGIN", "COMMIT", 'CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) IS NOT NULL)))']
   end
 
   it "should assume column is not a String if it can't determine the type" do
@@ -194,20 +198,22 @@ describe "constraint_validations extension" do
 
   it "should support :format constraint validation" do
     @db = Sequel.mock(:host=>'postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @db.extension(:constraint_validations)
     @db.create_table(:foo){String :name; validate{format(/^foo.*/, :name)}}
     sqls = @db.sqls
     parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"format", :column=>"name", :table=>"foo", :argument=>'^foo.*')
-    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~ '^foo.*')))"]
+    sqls.must_equal ["BEGIN", "COMMIT", %[CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~ '^foo.*')))]]
   end
 
   it "should support :format constraint validation with case insensitive format" do
     @db = Sequel.mock(:host=>'postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @db.extension(:constraint_validations)
     @db.create_table(:foo){String :name; validate{format(/^foo.*/i, :name)}}
     sqls = @db.sqls
     parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"iformat", :column=>"name", :table=>"foo", :argument=>'^foo.*')
-    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~* '^foo.*')))"]
+    sqls.must_equal ["BEGIN", "COMMIT", %[CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~* '^foo.*')))]]
   end
 
   it "should support :includes constraint validation with an array of strings" do

data/spec/extensions/core_refinements_spec.rb

@@ -6,14 +6,15 @@ using Sequel::CoreRefinements
 
 describe "Core refinements" do
   before do
-    db = Sequel::Database.new
-    @d = db[:items]
-    def @d.supports_regexp?; true end
-    def @d.l(*args, &block)
-      literal(filter_expr(*args, &block))
-    end
-    def @d.lit(*args)
-      literal(*args)
+    db = Sequel.mock
+    @d = db[:items].with_extend do
+      def supports_regexp?; true end
+      def l(*args, &block)
+        literal(filter_expr(*args, &block))
+      end
+      def lit(*args)
+        literal(*args)
+      end
     end
   end
   
@@ -184,7 +185,7 @@ end
 
 describe "String#lit" do
   before do
-    @ds = Sequel::Database.new[:t]
+    @ds = Sequel.mock[:t]
   end
 
   it "should return an LiteralString object" do
@@ -200,16 +201,14 @@ describe "String#lit" do
     a = 'DISTINCT ?'.lit(:a)
     a.must_be_kind_of(Sequel::SQL::PlaceholderLiteralString)
     @ds.literal(a).must_equal 'DISTINCT a'
-    @ds.quote_identifiers = true
-    @ds.literal(a).must_equal 'DISTINCT "a"'
+    @ds.with_quote_identifiers(true).literal(a).must_equal 'DISTINCT "a"'
   end
   
   it "should handle named placeholders if given a single argument hash" do
     a = 'DISTINCT :b'.lit(:b=>:a)
     a.must_be_kind_of(Sequel::SQL::PlaceholderLiteralString)
     @ds.literal(a).must_equal 'DISTINCT a'
-    @ds.quote_identifiers = true
-    @ds.literal(a).must_equal 'DISTINCT "a"'
+    @ds.with_quote_identifiers(true).literal(a).must_equal 'DISTINCT "a"'
   end
 
   it "should treat placeholder literal strings as generic expressions" do
@@ -285,11 +284,7 @@ end
 
 describe "Column references" do
   before do
-    @ds = Sequel::Database.new.dataset
-    def @ds.quoted_identifier_append(sql, c)
-      sql << "`#{c}`"
-    end
-    @ds.quote_identifiers = true
+    @ds = Sequel.mock.dataset.with_quote_identifiers(true).with_extend{def quoted_identifier_append(sql, c) sql << "`#{c}`" end}
   end
   
   it "should be quoted properly" do
@@ -349,30 +344,28 @@ end
 
 describe "Symbol" do
   before do
-    @ds = Sequel.mock.dataset
-    @ds.quote_identifiers = true
-    @ds.identifier_input_method = :upcase
+    @ds = Sequel.mock.dataset.with_quote_identifiers(true)
   end
 
   it "#identifier should format an identifier" do
-    @ds.literal(:xyz__abc.identifier).must_equal '"XYZ__ABC"'
+    @ds.literal(:xyz__abc.identifier).must_equal '"xyz__abc"'
   end
 
   it "#qualify should format a qualified column" do
-    @ds.literal(:xyz.qualify(:abc)).must_equal '"ABC"."XYZ"'
+    @ds.literal(:xyz.qualify(:abc)).must_equal '"abc"."xyz"'
   end
 
   it "#qualify should work on QualifiedIdentifiers" do
-    @ds.literal(:xyz.qualify(:abc).qualify(:def)).must_equal '"DEF"."ABC"."XYZ"'
+    @ds.literal(:xyz.qualify(:abc).qualify(:def)).must_equal '"def"."abc"."xyz"'
   end
 
   it "should be able to qualify an identifier" do
-    @ds.literal(:xyz.identifier.qualify(:xyz__abc)).must_equal '"XYZ"."ABC"."XYZ"'
+    @ds.literal(:xyz.identifier.qualify(:xyz__abc)).must_equal '"xyz"."abc"."xyz"'
   end
 
   it "should be able to specify a schema.table.column" do
-    @ds.literal(:column.qualify(:table.qualify(:schema))).must_equal '"SCHEMA"."TABLE"."COLUMN"'
-    @ds.literal(:column.qualify(:table__name.identifier.qualify(:schema))).must_equal '"SCHEMA"."TABLE__NAME"."COLUMN"'
+    @ds.literal(:column.qualify(:table.qualify(:schema))).must_equal '"schema"."table"."column"'
+    @ds.literal(:column.qualify(:table__name.identifier.qualify(:schema))).must_equal '"schema"."table__name"."column"'
   end
 
   it "should be able to specify order" do
@@ -387,13 +380,13 @@ describe "Symbol" do
   it "should work correctly with objects" do
     o = Object.new
     def o.sql_literal(ds) "(foo)" end
-    @ds.literal(:column.qualify(o)).must_equal '(foo)."COLUMN"'
+    @ds.literal(:column.qualify(o)).must_equal '(foo)."column"'
   end
 end
 
 describe "Symbol" do
   before do
-    @ds = Sequel::Database.new.dataset
+    @ds = Sequel.mock.dataset
   end
   
   it "should support sql_function method" do

data/spec/extensions/csv_serializer_spec.rb

@@ -95,7 +95,7 @@ describe "Sequel::Plugins::CsvSerializer" do
 
     @album = @Album.from_csv('2,AS', :headers=>[nil, 'name'])
     @album.name.must_equal 'AS'
-    @album.artist_id.must_equal nil
+    @album.artist_id.must_be_nil
   end
 
   it "#from_csv should support :headers to specify headers" do
@@ -109,8 +109,10 @@ describe "Sequel::Plugins::CsvSerializer" do
   end
 
   it "should support a to_csv class and dataset method" do
-    @Album.dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
-    @Artist.dataset._fetch = {:id=>2, :name=>'YJM'}
+    @Album.dataset = @Album.dataset.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
+    @Artist.dataset = @Artist.dataset.with_fetch(:id=>2, :name=>'YJM')
+    @Album.columns(:id, :name, :artist_id)
+    @Album.db_schema.replace(:id=>{:type=>:integer}, :artist_id=>{:type=>:integer})
     @Album.array_from_csv(@Album.to_csv).must_equal [@album]
     @Album.array_from_csv(@Album.dataset.to_csv(:only=>:name), :only=>:name).must_equal [@Album.load(:name=>@album.name)]
   end
@@ -166,9 +168,8 @@ describe "Sequel::Plugins::CsvSerializer" do
   it "should use a dataset's selected columns" do
     columns = [:id]
     ds = @Artist.select(*columns).limit(1)
-    ds.instance_variable_set(:@columns, columns)
-    ds._fetch = [:id => 10]
-    ds.to_csv(:write_headers => true).must_equal "id\n10\n"
+    ds.send(:columns=, columns)
+    ds.with_fetch(:id => 10).to_csv(:write_headers => true).must_equal "id\n10\n"
   end
 
   it "should pass all the examples from the documentation" do

data/spec/extensions/date_arithmetic_spec.rb

@@ -83,21 +83,21 @@ describe "date_arithmetic extension" do
   end
 
   it "should correctly literalize on Postgres" do
-    db = dbf.call(:postgres)
+    db = dbf.call(:postgres).dataset.with_quote_identifiers(false)
     db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
     db.literal(Sequel.date_add(:a, @h1)).must_equal "(CAST(a AS timestamp) + CAST('1 days ' AS interval))"
     db.literal(Sequel.date_add(:a, @h2)).must_equal "(CAST(a AS timestamp) + CAST('1 years 1 months 1 days 1 hours 1 minutes 1 seconds ' AS interval))"
   end
 
   it "should correctly literalize on SQLite" do
-    db = dbf.call(:sqlite)
+    db = dbf.call(:sqlite).dataset.with_quote_identifiers(false)
     db.literal(Sequel.date_add(:a, @h0)).must_equal "datetime(a)"
     db.literal(Sequel.date_add(:a, @h1)).must_equal "datetime(a, '1 days')"
     db.literal(Sequel.date_add(:a, @h2)).must_equal "datetime(a, '1 years', '1 months', '1 days', '1 hours', '1 minutes', '1 seconds')"
   end
 
   it "should correctly literalize on MySQL" do
-    db = dbf.call(:mysql)
+    db = dbf.call(:mysql).dataset.with_quote_identifiers(false)
     db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS DATETIME)"
     db.literal(Sequel.date_add(:a, @h1)).must_equal "DATE_ADD(a, INTERVAL 1 DAY)"
     db.literal(Sequel.date_add(:a, @h2)).must_equal "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(a, INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
@@ -113,10 +113,10 @@ describe "date_arithmetic extension" do
   end
 
   it "should correctly literalize on MSSQL" do
-    db = dbf.call(:mssql)
-    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS datetime)"
-    db.literal(Sequel.date_add(:a, @h1)).must_equal "DATEADD(day, 1, a)"
-    db.literal(Sequel.date_add(:a, @h2)).must_equal "DATEADD(second, 1, DATEADD(minute, 1, DATEADD(hour, 1, DATEADD(day, 1, DATEADD(month, 1, DATEADD(year, 1, a))))))"
+    db = dbf.call(:mssql).dataset.with_quote_identifiers(false)
+    db.literal(Sequel.date_add(:A, @h0)).must_equal "CAST(A AS datetime)"
+    db.literal(Sequel.date_add(:A, @h1)).must_equal "DATEADD(day, 1, A)"
+    db.literal(Sequel.date_add(:A, @h2)).must_equal "DATEADD(second, 1, DATEADD(minute, 1, DATEADD(hour, 1, DATEADD(day, 1, DATEADD(month, 1, DATEADD(year, 1, A))))))"
   end
 
   it "should correctly literalize on H2" do
@@ -129,7 +129,7 @@ describe "date_arithmetic extension" do
   end
 
   it "should correctly literalize on access" do
-    db = dbf.call(:access)
+    db = dbf.call(:access).dataset.with_quote_identifiers(false)
     db.literal(Sequel.date_add(:a, @h0)).must_equal "CDate(a)"
     db.literal(Sequel.date_add(:a, @h1)).must_equal "DATEADD('d', 1, a)"
     db.literal(Sequel.date_add(:a, @h2)).must_equal "DATEADD('s', 1, DATEADD('n', 1, DATEADD('h', 1, DATEADD('d', 1, DATEADD('m', 1, DATEADD('yyyy', 1, a))))))"
@@ -146,17 +146,17 @@ describe "date_arithmetic extension" do
   end
 
   it "should correctly literalize on Oracle" do
-    db = dbf.call(:oracle)
-    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).must_equal "(a + INTERVAL '1' DAY)"
-    db.literal(Sequel.date_add(:a, @h2)).must_equal "(a + INTERVAL '1' YEAR + INTERVAL '1' MONTH + INTERVAL '1' DAY + INTERVAL '1' HOUR + INTERVAL '1' MINUTE + INTERVAL '1' SECOND)"
+    db = dbf.call(:oracle).dataset.with_quote_identifiers(false)
+    db.literal(Sequel.date_add(:A, @h0)).must_equal "CAST(A AS timestamp)"
+    db.literal(Sequel.date_add(:A, @h1)).must_equal "(A + INTERVAL '1' DAY)"
+    db.literal(Sequel.date_add(:A, @h2)).must_equal "(A + INTERVAL '1' YEAR + INTERVAL '1' MONTH + INTERVAL '1' DAY + INTERVAL '1' HOUR + INTERVAL '1' MINUTE + INTERVAL '1' SECOND)"
   end
 
   it "should correctly literalize on DB2" do
     db = dbf.call(:db2)
-    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).must_equal "(CAST(a AS timestamp) + 1 days)"
-    db.literal(Sequel.date_add(:a, @h2)).must_equal "(CAST(a AS timestamp) + 1 years + 1 months + 1 days + 1 hours + 1 minutes + 1 seconds)"
+    db.literal(Sequel.date_add(:A, @h0)).must_equal "CAST(A AS timestamp)"
+    db.literal(Sequel.date_add(:A, @h1)).must_equal "(CAST(A AS timestamp) + 1 days)"
+    db.literal(Sequel.date_add(:A, @h2)).must_equal "(CAST(A AS timestamp) + 1 years + 1 months + 1 days + 1 hours + 1 minutes + 1 seconds)"
   end
 
   it "should raise error if literalizing on an unsupported database" do

data/spec/extensions/defaults_setter_spec.rb

@@ -63,7 +63,7 @@ describe "Sequel::Plugins::DefaultsSetter" do
   it "should not override a given value" do
     @pr.call(2)
     @c.new('a'=>3).a.must_equal 3
-    @c.new('a'=>nil).a.must_equal nil
+    @c.new('a'=>nil).a.must_be_nil
   end
 
   it "should work correctly when subclassing" do
@@ -90,7 +90,7 @@ describe "Sequel::Plugins::DefaultsSetter" do
   it "should have procs that set default values set them to nil" do
     @pr.call(2)
     @c.default_values[:a] = proc{nil}
-    @c.new.a.must_equal nil
+    @c.new.a.must_be_nil
   end
 
   it "should work correctly on a model without a dataset" do

data/spec/extensions/delay_add_association_spec.rb

@@ -45,7 +45,7 @@ describe "Sequel::Plugins::DelayAddAssociation" do
     @c.send(:define_method, :validate){|*| errors.add(:name, 'is b') if name == 'b'}
     @o = @c.new(:name=>'a')
     @o.add_c(@c.load(:id=>2, :name=>'b'))
-    @o.save.must_equal nil
+    @o.save.must_be_nil
     @o.errors[:cs].must_equal ["name is b"]
     @o.cs.first.errors[:name].must_equal ['is b']
   end

data/spec/extensions/dirty_spec.rb

@@ -11,19 +11,19 @@ describe "Sequel::Plugins::Dirty" do
   dirty_plugin_specs = shared_description do
     it "initial_value should be the current value if value has not changed" do
       @o.initial_value(:initial).must_equal 'i'
-      @o.initial_value(:missing).must_equal nil
+      @o.initial_value(:missing).must_be_nil
     end
 
     it "initial_value should be the intial value if value has changed" do
       @o.initial_value(:initial_changed).must_equal 'ic'
-      @o.initial_value(:missing_changed).must_equal nil
+      @o.initial_value(:missing_changed).must_be_nil
     end
 
     it "initial_value should handle case where initial value is reassigned later" do
       @o.initial_changed = 'ic'
       @o.initial_value(:initial_changed).must_equal 'ic'
       @o.missing_changed = nil
-      @o.initial_value(:missing_changed).must_equal nil
+      @o.initial_value(:missing_changed).must_be_nil
     end
 
     it "changed_columns should handle case where initial value is reassigned later" do
@@ -40,8 +40,8 @@ describe "Sequel::Plugins::Dirty" do
     end
 
     it "column_change should be nil if no change has been made" do
-      @o.column_change(:initial).must_equal nil
-      @o.column_change(:missing).must_equal nil
+      @o.column_change(:initial).must_be_nil
+      @o.column_change(:missing).must_be_nil
     end
 
     it "column_changed? should return whether the column has changed" do
@@ -76,9 +76,9 @@ describe "Sequel::Plugins::Dirty" do
       @o.reset_column(:initial_changed)
       @o.initial_changed.must_equal 'ic'
       @o.reset_column(:missing)
-      @o.missing.must_equal nil
+      @o.missing.must_be_nil
       @o.reset_column(:missing_changed)
-      @o.missing_changed.must_equal nil
+      @o.missing_changed.must_be_nil
     end
 
     it "reset_column should remove missing values from the values" do
@@ -124,11 +124,18 @@ describe "Sequel::Plugins::Dirty" do
     end
 
     it "should have #dup duplicate structures" do
+      was_new = @o.new?
+      @o.update(:missing=>'m2')
       @o.dup.initial_values.must_equal @o.initial_values
       @o.dup.initial_values.wont_be_same_as(@o.initial_values)
       @o.dup.instance_variable_get(:@missing_initial_values).must_equal @o.instance_variable_get(:@missing_initial_values)
       @o.dup.instance_variable_get(:@missing_initial_values).wont_be_same_as(@o.instance_variable_get(:@missing_initial_values))
-      @o.dup.previous_changes.must_equal @o.previous_changes
+      if was_new
+        @o.previous_changes.must_be_nil
+        @o.dup.previous_changes.must_be_nil
+      else
+        @o.dup.previous_changes.must_equal @o.previous_changes
+      end
       @o.dup.previous_changes.wont_be_same_as(@o.previous_changes) if @o.previous_changes
     end
   end
@@ -148,8 +155,10 @@ describe "Sequel::Plugins::Dirty" do
     end
 
     it "save_changes should clear the cached initial values" do
-      def (@c.instance_dataset).supports_insert_select?() true end
-      def (@c.instance_dataset).insert_select(*) {:id=>1} end
+      @c.dataset = @c.dataset.with_extend do
+        def supports_insert_select?; true end
+        def insert_select(*) {:id=>1} end
+      end
       @o.save
       @o.column_changes.must_equal({})
     end