sequel 4.40.0 → 4.41.0

data/lib/sequel/plugins/json_serializer.rb

@@ -13,7 +13,7 @@ module Sequel
     #
     #   album = Album[1]
     #   album.to_json
-    #   # => '{"json_class"=>"Album","id"=>1,"name"=>"RF","artist_id"=>2}'
+    #   # => '{"id"=>1,"name"=>"RF","artist_id"=>2}'
     #
     # In addition, you can provide options to control the JSON output:
     #
@@ -22,16 +22,23 @@ module Sequel
     #   # => '{"json_class"="Album","name"=>"RF"}'
     #   
     #   album.to_json(:include=>:artist)
-    #   # => '{"json_class":"Album","id":1,"name":"RF","artist_id":2,
-    #   #      "artist":{"json_class":"Artist","id":2,"name":"YJM"}}'
+    #   # => '{"id":1,"name":"RF","artist_id":2,
+    #   #      "artist":{"id":2,"name":"YJM"}}'
     # 
     # You can use a hash value with <tt>:include</tt> to pass options
     # to associations:
     #
     #   album.to_json(:include=>{:artist=>{:only=>:name}})
-    #   # => '{"json_class":"Album","id":1,"name":"RF","artist_id":2,
-    #   #      "artist":{"json_class":"Artist","name":"YJM"}}'
+    #   # => '{"id":1,"name":"RF","artist_id":2,
+    #   #      "artist":{"name":"YJM"}}'
     #
+    # You can specify a name for a given association by passing <tt>:name</tt>
+    # to the <tt>:include</tt> hash
+    #
+    #   album.to_json(:include=>{Sequel.as(:artist, :singer)=>{:only=>:name}})
+    #   # => '{"id":1,"name":"RF","artist_id":2,
+    #   #      "singer":{"name":"YJM"}}'
+    # 
     # You can specify the <tt>:root</tt> option to nest the JSON under the
     # name of the model:
     #
@@ -299,6 +306,13 @@ module Sequel
           if inc = opts[:include]
             if inc.is_a?(Hash)
               inc.each do |k, v|
+                if k.is_a?(Sequel::SQL::AliasedExpression)
+                  key_name = k.aliaz.to_s
+                  k = k.expression
+                else
+                  key_name = k.to_s
+                end
+
                 v = v.empty? ? [] : [v]
 
                 objs = send(k)
@@ -309,14 +323,22 @@ module Sequel
                   objs.is_a?(Array)
                 end
                 
-                h[k.to_s] = if is_array
+                h[key_name] = if is_array
                   objs.map{|obj| Literal.new(Sequel.object_to_json(obj, *v))}
                 else
                   Literal.new(Sequel.object_to_json(objs, *v))
                 end
               end
             else
-              Array(inc).each{|c| h[c.to_s] = send(c)}
+              Array(inc).each do |c|
+                if c.is_a?(Sequel::SQL::AliasedExpression)
+                  key_name = c.aliaz.to_s
+                  c = c.expression
+                else
+                  key_name = c.to_s
+                end
+                h[key_name] = send(c)
+              end
             end
           end
 

data/lib/sequel/version.rb

@@ -5,7 +5,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 40
+  MINOR = 41
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/firebird_spec.rb

@@ -58,9 +58,8 @@ end
 
 describe "A Firebird dataset" do
   before do
-    @d = DB[:test]
-    @d.delete # remove all records
-    @d.quote_identifiers = true
+    @d = DB[:test].with_quote_identifiers(true)
+    @d.delete
   end
 
   it "should return the correct record count" do
@@ -90,8 +89,6 @@ describe "A Firebird dataset" do
     @d << {:name => 'def', :val => 789}
     @d.filter(:name => 'abc').update(:val => 530)
 
-    # the third record should stay the same
-    # floating-point precision bullshit
     @d[:name => 'def'][:val].must_equal 789
     @d.filter(:val => 530).count.must_equal 2
   end
@@ -112,7 +109,6 @@ describe "A Firebird dataset" do
   end
 
   it "should quote columns and tables using double quotes if quoting identifiers" do
-    @d.quote_identifiers = true
     @d.select(:name).sql.must_equal \
       'SELECT "NAME" FROM "TEST"'
 
@@ -157,7 +153,6 @@ describe "A Firebird dataset" do
   end
 
   it "should quote fields correctly when reversing the order if quoting identifiers" do
-    @d.quote_identifiers = true
     @d.reverse_order(:name).sql.must_equal \
       'SELECT * FROM "TEST" ORDER BY "NAME" DESC'
 
@@ -220,7 +215,6 @@ describe "A Firebird dataset" do
 
   it "should quote and upcase reserved keywords" do
     @d = DB[:testing]
-    @d.quote_identifiers = true
     @d.select(:select).sql.must_equal \
       'SELECT "SELECT" FROM "TESTING"'
   end

data/spec/adapters/mssql_spec.rb

@@ -247,7 +247,7 @@ describe "Offset support" do
     @db.create_table!(:i){Integer :id; Integer :parent_id}
     @ds = @db[:i].order(:id)
     @hs = []
-    @ds.row_proc = proc{|r| @hs << r.dup; r[:id] *= 2; r[:parent_id] *= 3; r}
+    @ds = @ds.with_row_proc(proc{|r| @hs << r.dup; r[:id] *= 2; r[:parent_id] *= 3; r})
     @ds.import [:id, :parent_id], [[1,nil],[2,nil],[3,1],[4,1],[5,3],[6,5]]
   end
   after do
@@ -356,7 +356,9 @@ describe "MSSSQL::Dataset#insert" do
   end
   
   it "should have insert_select return nil if the server version is not 2005+" do
-    def @ds.server_version() 8000760 end
+    @ds = @ds.with_extend(Module.new do
+      def server_version() 8000760 end
+    end)
     @ds.insert_select(:value=>10).must_equal nil
   end
 
@@ -424,20 +426,16 @@ describe "A MSSQL database" do
 end
 
 describe "MSSQL::Database#rename_table" do
-  after do
-    DB.drop_table?(:foo)
-  end
-
   it "should work on non-schema bound tables which need escaping" do
     DB.quote_identifiers = true
     DB.create_table! :'foo bar' do
       text :name
     end
-    DB.drop_table? :foo
     DB.rename_table 'foo bar', 'foo'
+    DB.drop_table :foo
   end
   
-  it "should work on schema bound tables" do
+  it "should work on schema bound tables within the same schema" do
     DB.execute(<<-SQL)
       IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = 'MY')
         EXECUTE sp_executesql N'create schema MY'
@@ -447,6 +445,7 @@ describe "MSSQL::Database#rename_table" do
     end
     DB.rename_table Sequel[:MY][:foo], Sequel[:MY][:bar]
     DB.rename_table Sequel[:MY][:bar], :foo
+    DB.drop_table Sequel[:MY][:foo]
   end
 end
 
@@ -488,10 +487,11 @@ describe "MSSQL::Database#mssql_unicode_strings = false" do
     DB.create_table!(:items){String :name}
     ds = DB[:items]
     ds.mssql_unicode_strings.must_equal false
-    ds.mssql_unicode_strings = true
-    ds.mssql_unicode_strings.must_equal true
-    ds.insert(:name=>'foo')
-    ds.select_map(:name).must_equal ['foo']
+    ds1 = ds.with_mssql_unicode_strings(true)
+    ds.mssql_unicode_strings.must_equal false
+    ds1.mssql_unicode_strings.must_equal true
+    ds1.insert(:name=>'foo')
+    ds1.select_map(:name).must_equal ['foo']
   end
 end
 

data/spec/adapters/mysql_spec.rb

@@ -150,9 +150,10 @@ if [:mysql, :mysql2].include?(DB.adapter_scheme)
 
     it "should allow disabling the conversion on a per-dataset basis" do
       @db.convert_tinyint_to_bool = true
-      ds = @ds.clone
-      def ds.cast_tinyint_integer?(f) true end #mysql
-      def ds.convert_tinyint_to_bool?() false end #mysql2
+      ds = @ds.with_extend(Module.new do
+        def cast_tinyint_integer?(f) true end #mysql
+        def convert_tinyint_to_bool?() false end #mysql2
+      end)
       ds.delete
       ds << {:b=>true, :i=>10}
       ds.all.must_equal [{:b=>1, :i=>10}]
@@ -172,7 +173,7 @@ describe "A MySQL dataset" do
   end
 
   it "should quote columns and tables using back-ticks if quoting identifiers" do
-    @d.quote_identifiers = true
+    @d = @d.with_quote_identifiers(true)
     @d.select(:name).sql.must_equal 'SELECT `name` FROM `items`'
     @d.select(Sequel.lit('COUNT(*)')).sql.must_equal 'SELECT COUNT(*) FROM `items`'
     @d.select(Sequel.function(:max, :value)).sql.must_equal 'SELECT max(`value`) FROM `items`'
@@ -190,7 +191,7 @@ describe "A MySQL dataset" do
   end
 
   it "should quote fields correctly when reversing the order" do
-    @d.quote_identifiers = true
+    @d = @d.with_quote_identifiers(true)
     @d.reverse_order(:name).sql.must_equal 'SELECT * FROM `items` ORDER BY `name` DESC'
     @d.reverse_order(Sequel.desc(:name)).sql.must_equal 'SELECT * FROM `items` ORDER BY `name` ASC'
     @d.reverse_order(:name, Sequel.desc(:test)).sql.must_equal 'SELECT * FROM `items` ORDER BY `name` DESC, `test` ASC'
@@ -242,7 +243,7 @@ describe "MySQL datasets" do
   end
 
   it "should correctly quote column references" do
-    @d.quote_identifiers = true
+    @d = @d.with_quote_identifiers(true)
     market = 'ICE'
     ack_stamp = Time.now - 15 * 60 # 15 minutes ago
     @d.select(:market, Sequel.function(:minute, Sequel.function(:from_unixtime, :ack)).as(:minute)).
@@ -321,8 +322,7 @@ describe "Joined MySQL dataset" do
   end
 
   it "should quote fields correctly" do
-    @ds.quote_identifiers = true
-    @ds.join(:attributes, :node_id => :id).sql.must_equal "SELECT * FROM `nodes` INNER JOIN `attributes` ON (`attributes`.`node_id` = `nodes`.`id`)"
+    @ds.with_quote_identifiers(true).join(:attributes, :node_id => :id).sql.must_equal "SELECT * FROM `nodes` INNER JOIN `attributes` ON (`attributes`.`node_id` = `nodes`.`id`)"
   end
 
   it "should put a having clause before an order by clause" do
@@ -1168,7 +1168,7 @@ if DB.adapter_scheme == :mysql or DB.adapter_scheme == :jdbc or DB.adapter_schem
         @d.call_sproc(:select, :test_sproc, 3).must_equal []
         @d.insert(:value=>1)
         @d.call_sproc(:select, :test_sproc, 4).must_equal [{:id=>nil, :value=>1, :b=>4}]
-        @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
+        @d = @d.with_row_proc(proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r})
         @d.call_sproc(:select, :test_sproc, 3).must_equal [{:id=>nil, :value=>2, :b=>6}]
       end
 
@@ -1179,7 +1179,7 @@ if DB.adapter_scheme == :mysql or DB.adapter_scheme == :jdbc or DB.adapter_schem
         @d.call_sproc(:select, :test_sproc, 3, 4).must_equal []
         @d.insert(:value=>1)
         @d.call_sproc(:select, :test_sproc, 4, 5).must_equal [{:id=>nil, :value=>1, :b=>4, :d=>5}]
-        @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
+        @d = @d.with_row_proc(proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r})
         @d.call_sproc(:select, :test_sproc, 3, 4).must_equal [{:id=>nil, :value=>2, :b=>6, :d => 8}]
       end
     end
@@ -1259,7 +1259,7 @@ if DB.adapter_scheme == :mysql
     end
 
     it "should have regular row_procs work when splitting multiple result sets" do
-      @ds.row_proc = proc{|x| x[x.keys.first] *= 2; x}
+      @ds = @ds.with_row_proc(proc{|x| x[x.keys.first] *= 2; x})
       @ds.split_multiple_result_sets.all.must_equal [[{:a=>20}, {:a=>30}], [{:b=>40}, {:b=>50}]]
     end
 

data/spec/adapters/postgres_spec.rb

@@ -964,13 +964,10 @@ describe "A PostgreSQL database" do
     @db[:posts].order(:a).map(:a).must_equal [1, 2, 10, 20, 21]
   end
     
-  it "should support specifying Integer/Bignum/Fixnum types in primary keys and have them be auto incrementing" do
+  it "should support specifying Integer/Bignum types in primary keys and have them be auto incrementing" do
     @db.create_table(:posts){primary_key :a, :type=>Integer}
     @db[:posts].insert.must_equal 1
     @db[:posts].insert.must_equal 2
-    @db.create_table!(:posts){primary_key :a, :type=>Fixnum}
-    @db[:posts].insert.must_equal 1
-    @db[:posts].insert.must_equal 2
     @db.create_table!(:posts){primary_key :a, :type=>:Bignum}
     @db[:posts].insert.must_equal 1
     @db[:posts].insert.must_equal 2
@@ -1730,11 +1727,13 @@ if DB.adapter_scheme == :postgres
     end
 
     it "should handle returning inside block" do
-      def @ds.check_return
-        use_cursor.each{|r| return}
-      end
-      @ds.check_return
-      @ds.all.must_equal @ds.use_cursor.all
+      ds = @ds.with_extend(Module.new do
+        def check_return
+          use_cursor.each{|r| return}
+        end
+      end)
+      ds.check_return
+      ds.all.must_equal ds.use_cursor.all
     end
   end
 

data/spec/adapters/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'logger'
+require "#{File.dirname(File.dirname(__FILE__))}/sequel_warning.rb"
 
 if ENV['COVERAGE']
   require File.join(File.dirname(File.expand_path(__FILE__)), "../sequel_coverage")

data/spec/adapters/sqlite_spec.rb

@@ -457,9 +457,7 @@ describe "SQLite dataset" do
   end
   
   it "should have #explain work when identifier_output_method is modified" do
-    ds = DB[:test]
-    ds.identifier_output_method = :upcase
-    ds.explain.must_be_kind_of(String)
+    DB[:test].with_identifier_output_method(:upcase).explain.must_be_kind_of(String)
   end
 end
 

data/spec/core/database_spec.rb

@@ -1899,8 +1899,9 @@ describe "Database#raise_error" do
     def @db.database_error_regexps
       {/foo/ => Sequel::DatabaseDisconnectError, /bar/ => Sequel::ConstraintViolation}
     end
-    proc{@db.send(:raise_error, Interrupt.new('foo'))}.must_raise(Sequel::DatabaseDisconnectError)
-    proc{@db.send(:raise_error, Interrupt.new('bar'))}.must_raise(Sequel::ConstraintViolation)
+    e = Class.new(StandardError)
+    proc{@db.send(:raise_error, e.new('foo'))}.must_raise(Sequel::DatabaseDisconnectError)
+    proc{@db.send(:raise_error, e.new('bar'))}.must_raise(Sequel::ConstraintViolation)
   end
 end
 

data/spec/core/dataset_spec.rb

@@ -89,6 +89,33 @@ describe "Dataset" do
     @dataset.send(:output_identifier, "at_b_C").must_equal :C_b_ta
   end
   
+  it "should have with_quote_identifiers method which returns cloned dataset with changed literalization of identifiers" do
+    @dataset.with_quote_identifiers(true).literal(:a).must_equal '"a"'
+    @dataset.with_quote_identifiers(false).literal(:a).must_equal 'a'
+    ds = @dataset.freeze.with_quote_identifiers(false)
+    ds.literal(:a).must_equal 'a'
+    ds.frozen?.must_equal true
+  end
+  
+  it "should have with_identifier_input_method method which returns cloned dataset with changed literalization of identifiers" do
+    @dataset.with_identifier_input_method(:upcase).literal(:a).must_equal 'A'
+    @dataset.with_identifier_input_method(:downcase).literal(:A).must_equal 'a'
+    @dataset.with_identifier_input_method(:reverse).literal(:at_b).must_equal 'b_ta'
+    ds = @dataset.freeze.with_identifier_input_method(:reverse)
+    ds.frozen?.must_equal true
+    ds.literal(:at_b).must_equal 'b_ta'
+  end
+  
+  it "should have with_identifier_output_method method which returns cloned dataset with changed identifiers returned from the database" do
+    @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_C
+    @dataset.with_identifier_output_method(:upcase).send(:output_identifier, "at_b_C").must_equal :AT_B_C
+    @dataset.with_identifier_output_method(:downcase).send(:output_identifier, "at_b_C").must_equal :at_b_c
+    @dataset.with_identifier_output_method(:reverse).send(:output_identifier, "at_b_C").must_equal :C_b_ta
+    ds = @dataset.freeze.with_identifier_output_method(:reverse)
+    ds.send(:output_identifier, "at_b_C").must_equal :C_b_ta
+    ds.frozen?.must_equal true
+  end
+  
   it "should have output_identifier handle empty identifiers" do
     @dataset.send(:output_identifier, "").must_equal :untitled
     @dataset.identifier_output_method = :upcase
@@ -167,8 +194,7 @@ describe "Dataset#==" do
   
   it "should be different for datasets with different SQL" do
     ds = @db[:t]
-    ds.quote_identifiers = true
-    ds.wont_equal @db[:t]
+    ds.with_quote_identifiers(true).wont_equal ds
   end
 end
 
@@ -194,8 +220,7 @@ describe "Dataset#hash" do
   
   it "should be different for datasets with different SQL" do
     ds = @db[:t]
-    ds.quote_identifiers = true
-    ds.hash.wont_equal @db[:t].hash
+    ds.with_quote_identifiers(true).hash.wont_equal ds.hash
   end
 end
 
@@ -937,7 +962,7 @@ describe "Dataset#literal" do
   end
 
   it "should support spaces inside column names" do
-    @ds.quote_identifiers = true
+    @ds = @ds.with_quote_identifiers(true)
     @ds.literal(:"AB C").must_equal '"AB C"'
     @ds.literal(:"Zvas htoy__aB cD").must_equal '"Zvas htoy"."aB cD"'
     @ds.literal(:"aB cD___XX XX").must_equal '"aB cD" AS "XX XX"'
@@ -1061,7 +1086,7 @@ describe "Dataset#literal" do
   end
   
   it "should not modify literal strings" do
-    @dataset.quote_identifiers = true
+    @dataset = @dataset.with_quote_identifiers(true)
     @dataset.literal(Sequel.lit('col1 + 2')).must_equal 'col1 + 2'
     @dataset.update_sql(Sequel::SQL::Identifier.new(Sequel.lit('a')) => Sequel.lit('a + 2')).must_equal 'UPDATE "test" SET a = a + 2'
   end
@@ -1115,12 +1140,11 @@ describe "Dataset#from" do
   end
   
   it "should treat string arguments as identifiers" do
-    @dataset.quote_identifiers = true
-    @dataset.from('a').select_sql.must_equal "SELECT * FROM \"a\""
+    @dataset.with_quote_identifiers(true).from('a').select_sql.must_equal "SELECT * FROM \"a\""
   end
   
   it "should not treat literal strings or blobs as identifiers" do
-    @dataset.quote_identifiers = true
+    @dataset = @dataset.with_quote_identifiers(true)
     @dataset.from(Sequel.lit('a')).select_sql.must_equal "SELECT * FROM a"
     @dataset.from(Sequel.blob('a')).select_sql.must_equal "SELECT * FROM 'a'"
   end
@@ -1671,6 +1695,31 @@ describe "Dataset#offset" do
   end
 end
 
+describe "Dataset#with_extend" do
+  it "should returned clone dataset extended with given modules" do
+    d = Sequel.mock.dataset
+    m1 = Module.new{def a; 1; end}
+    m2 = Module.new{def b; a+2; end}
+    d.with_extend(m1, m2).b.must_equal 3
+    d.respond_to?(:b).must_equal false
+    ds = d.freeze.with_extend(m1, m2)
+    ds.b.must_equal 3
+    ds.frozen?.must_equal true
+  end
+end
+
+describe "Dataset#with_row_proc" do
+  it "should returned clone dataset with the given row_proc" do
+    d = Sequel.mock.dataset
+    l = lambda{|r| r}
+    d.with_row_proc(l).row_proc.must_equal l
+    assert_equal nil, d.row_proc
+    ds = d.freeze.with_row_proc(l)
+    ds.frozen?.must_equal true
+    ds.row_proc.must_equal l
+  end
+end
+
 describe "Dataset#naked" do
   it "should returned clone dataset without row_proc" do
     d = Sequel.mock.dataset
@@ -2126,8 +2175,7 @@ end
 
 describe "Dataset#join_table" do
   before do
-    @d = Sequel.mock.dataset.from(:items)
-    @d.quote_identifiers = true
+    @d = Sequel.mock.dataset.from(:items).with_quote_identifiers(true)
   end
   
   it "should format the JOIN clause properly" do
@@ -2791,7 +2839,7 @@ describe "Dataset#single_value!" do
   
   it "should call each and return the first value of the first record" do
     @db.fetch = [{:a=>1, :b=>2}, {:a=>3, :b=>4}]
-    @db[:test].single_value!.to_s.must_match /\A(1|2)\z/
+    @db[:test].single_value!.to_s.must_match(/\A(1|2)\z/)
     @db.sqls.must_equal ['SELECT * FROM test']
   end
   
@@ -3302,8 +3350,7 @@ describe "Dataset#insert_sql" do
   end
 
   it "should quote string keys" do
-    @ds.quote_identifiers = true
-    @ds.insert_sql('c' => 'd').must_equal "INSERT INTO \"items\" (\"c\") VALUES ('d')"
+    @ds.with_quote_identifiers(true).insert_sql('c' => 'd').must_equal "INSERT INTO \"items\" (\"c\") VALUES ('d')"
   end
 
   it "should accept array subscript references" do
@@ -3712,7 +3759,6 @@ describe "Dataset prepared statements and bound variables " do
   end
 
   it "should handle usage with Dataset.prepared_statements_module" do
-    m = Module.new
     @ds.extend(Sequel::Dataset.send(:prepared_statements_module, :prepare_bind, [Sequel::Dataset::ArgumentMapper, Sequel::Dataset::PreparedStatementMethods]){def foo; :bar; end})
     @ds.foo.must_equal :bar
     @ds.prepared_statement_name = 'foo'
@@ -4016,7 +4062,7 @@ describe "Sequel::Dataset #with and #with_recursive" do
   end
   
   it "#with and #with_recursive should quote the columns in the :args option" do
-    @ds.quote_identifiers = true
+    @ds = @ds.with_quote_identifiers(true)
     @ds.with(:t, @db[:x], :args=>[:b]).sql.must_equal 'WITH "t"("b") AS (SELECT * FROM x) SELECT * FROM "t"'
     @ds.with_recursive(:t, @db[:x], @db[:t], :args=>[:b, :c]).sql.must_equal 'WITH "t"("b", "c") AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM "t"'
   end
@@ -4631,8 +4677,7 @@ end
 
 describe "Dataset emulating bitwise operator support" do
   before do
-    @ds = Sequel::Database.new.dataset
-    @ds.quote_identifiers = true
+    @ds = Sequel::Database.new.dataset.with_quote_identifiers(true)
     def @ds.complex_expression_sql_append(sql, op, args)
       complex_expression_arg_pairs_append(sql, args){|a, b| Sequel.function(:bitand, a, b)}
     end
@@ -4681,20 +4726,19 @@ describe "Dataset extensions" do
   end
 
   it "should be able to register an extension with a block and Database#extension call the block" do
-    @ds.quote_identifiers = false
+    @ds = @ds.with_quote_identifiers(false)
     Sequel::Dataset.register_extension(:foo){|db| db.quote_identifiers = true}
     @ds.extension(:foo).quote_identifiers?.must_equal true
   end
 
   it "should be able to register an extension with a callable and Database#extension call the callable" do
-    @ds.quote_identifiers = false
+    @ds = @ds.with_quote_identifiers(false)
     Sequel::Dataset.register_extension(:foo, proc{|db| db.quote_identifiers = true})
     @ds.extension(:foo).quote_identifiers?.must_equal true
   end
 
   it "should be able to load multiple extensions in the same call" do
-    @ds.quote_identifiers = false
-    @ds.identifier_input_method = :downcase
+    @ds = @ds.with_quote_identifiers(false).with_identifier_input_method(:downcase)
     Sequel::Dataset.register_extension(:foo, proc{|ds| ds.quote_identifiers = true})
     Sequel::Dataset.register_extension(:bar, proc{|ds| ds.identifier_input_method = nil})
     ds = @ds.extension(:foo, :bar)