sequel 4.41.0 → 4.42.0

data/spec/adapters/spec_helper.rb

@@ -39,10 +39,15 @@ class Minitest::HooksSpec
   end
 end
 
+IDENTIFIER_MANGLING = !ENV['SEQUEL_NO_MANGLE'] unless defined?(IDENTIFIER_MANGLING)
+
 unless defined?(DB)
   env_var = "SEQUEL_#{SEQUEL_ADAPTER_TEST.to_s.upcase}_URL"
   env_var = ENV.has_key?(env_var) ? env_var : 'SEQUEL_INTEGRATION_URL'
-  DB = Sequel.connect(ENV[env_var])
+  opts = {}
+  opts[:identifier_mangling] = false unless IDENTIFIER_MANGLING
+  DB = Sequel.connect(ENV[env_var], opts)
+  DB.extension(:freeze_datasets) if ENV['SEQUEL_FREEZE_DATASETS']
 end
 
 if dch = ENV['SEQUEL_DUPLICATE_COLUMNS_HANDLER']

data/spec/adapters/sqlite_spec.rb

@@ -297,7 +297,7 @@ end if DB.adapter_scheme == :sqlite
 
 describe "An SQLite dataset" do
   before do
-    @d = DB[:items]
+    @d = DB.dataset
   end
   
   it "should raise errors if given a regexp pattern match" do
@@ -347,6 +347,9 @@ describe "SQLite::Dataset#delete" do
     @d << {:name => 'def', :value => 4.56}
     @d << {:name => 'ghi', :value => 7.89}
   end
+  after do
+    DB.drop_table?(:items)
+  end
   
   it "should return the number of records affected when filtered" do
     @d.count.must_equal 3
@@ -458,7 +461,7 @@ describe "SQLite dataset" do
   
   it "should have #explain work when identifier_output_method is modified" do
     DB[:test].with_identifier_output_method(:upcase).explain.must_be_kind_of(String)
-  end
+  end if IDENTIFIER_MANGLING
 end
 
 describe "A SQLite database" do
@@ -470,7 +473,7 @@ describe "A SQLite database" do
     end
   end
   after do
-    @db.drop_table?(:test2)
+    @db.drop_table?(:test, :test2, :test3, :test3_backup0, :test3_backup1, :test3_backup2)
   end
 
   it "should support add_column operations" do
@@ -543,12 +546,10 @@ describe "A SQLite database" do
       @db.drop_column :test3, :value
 
       @db[:test].filter(:name => 'bar').delete
-      @db[:test3][:name => 'def'][:test_id].must_equal nil
+      @db[:test3][:name => 'def'][:test_id].must_be_nil
 
       @db[:test].filter(:name => 'foo').update(:id=>100)
       @db[:test3][:name => 'abc'][:test_id].must_equal 100
-
-      @db.drop_table? :test, :test3
     end
   end
 
@@ -582,9 +583,23 @@ describe "A SQLite database" do
     @db[:test3].first[:t].must_equal 'a'
     @db[:test3].delete
   end
+
+
+  it "should preserve autoincrement after table modification" do
+    @db.create_table!(:test2) do
+      primary_key :id
+      Integer :val, :null => false
+    end
+    @db.rename_column(:test2, :val, :value)
+
+    t = @db[:test2]
+    id1 = t.insert(:value=>1)
+    t.delete
+    id2 = t.insert(:value=>1)
+    id2.must_be :>, id1
+  end
   
   it "should handle quoted tables when dropping or renaming columns" do
-    @db.quote_identifiers = true
     table_name = "T T"
     @db.drop_table?(table_name)
     @db.create_table! table_name do
@@ -640,7 +655,6 @@ describe "A SQLite database" do
     @db[:test3_backup1].columns.must_equal [:k]
     @db[:test3_backup2].columns.must_equal [:l]
     @db.loggers.delete(l)
-    @db.drop_table?(:test3, :test3_backup0, :test3_backup1, :test3_backup2)
   end
   
   it "should support add_index" do
@@ -654,12 +668,12 @@ describe "A SQLite database" do
   end
 
   it "should keep applicable indexes when emulating schema methods" do
-    @db.create_table!(:a){Integer :a; Integer :b}
-    @db.add_index :a, :a
-    @db.add_index :a, :b
-    @db.add_index :a, [:b, :a]
-    @db.drop_column :a, :b
-    @db.indexes(:a).must_equal(:a_a_index=>{:unique=>false, :columns=>[:a]})
+    @db.create_table!(:test3){Integer :a; Integer :b}
+    @db.add_index :test3, :a
+    @db.add_index :test3, :b
+    @db.add_index :test3, [:b, :a]
+    @db.drop_column :test3, :b
+    @db.indexes(:test3).must_equal(:test3_a_index=>{:unique=>false, :columns=>[:a]})
   end
 
   it "should have support for various #transaction modes" do
@@ -679,7 +693,7 @@ describe "A SQLite database" do
       sqls.last.must_equal Sequel::Database::SQL_BEGIN
     end
 
-    @db.transaction_mode.must_equal nil
+    @db.transaction_mode.must_be_nil
     @db.transaction_mode = :immediate
     @db.transaction_mode.must_equal :immediate
     @db.transaction do

data/spec/core/connection_pool_spec.rb

@@ -192,7 +192,7 @@ describe "A connection pool with a max size of 1" do
     
     cc.must_equal 'herro'
     c1.must_equal 'herro'
-    c2.must_equal nil
+    c2.must_be_nil
     
     @pool.available_connections.must_be :empty?
     @pool.allocated.must_equal(t1=>cc)
@@ -357,9 +357,9 @@ ThreadedConnectionPoolSpecs = shared_description do
     threads[6].must_be :alive?
     threads[7].must_be :alive?
     cc.size.must_equal 5
-    cc[5].must_equal nil
-    cc[6].must_equal nil
-    cc[7].must_equal nil
+    cc[5].must_be_nil
+    cc[6].must_be_nil
+    cc[7].must_be_nil
     
     5.times{q.push nil}
     5.times{|i| threads[i].join}
@@ -614,12 +614,12 @@ describe "A connection pool with multiple servers" do
     pool.hold(:server1) do
       pool.allocated.length.must_equal 0
       pool.allocated(:server1).length.must_equal 1
-      pool.allocated(:server2).must_equal nil
-      pool.allocated(:server3).must_equal nil
+      pool.allocated(:server2).must_be_nil
+      pool.allocated(:server3).must_be_nil
       pool.available_connections.length.must_equal 1
       pool.available_connections(:server1).length.must_equal 0
-      pool.available_connections(:server2).must_equal nil
-      pool.available_connections(:server3).must_equal nil
+      pool.available_connections(:server2).must_be_nil
+      pool.available_connections(:server3).must_be_nil
 
       pool.add_servers([:server2, :server3])
       pool.hold(:server2){}
@@ -717,8 +717,8 @@ describe "A connection pool with multiple servers" do
     pool.available_connections(:server1).must_equal []
     pool.allocated(:server1).must_equal({})
     pool.remove_servers([:server1])
-    pool.available_connections(:server1).must_equal nil
-    pool.allocated(:server1).must_equal nil
+    pool.available_connections(:server1).must_be_nil
+    pool.allocated(:server1).must_be_nil
   end
   
   it "#remove_servers should not allow the removal of the default server" do
@@ -832,7 +832,7 @@ describe "A single threaded pool with multiple servers" do
     @pool.hold(:read_only){|c| c.must_equal :read_only}
     @pool.conn(:read_only).must_equal :read_only
     @pool.remove_servers([:read_only])
-    @pool.conn(:read_only).must_equal nil
+    @pool.conn(:read_only).must_be_nil
     @pool.hold{}
     @pool.conn(:read_only).must_equal :default
   end
@@ -885,8 +885,8 @@ describe "A single threaded pool with multiple servers" do
     @pool.conn(:read_only).must_equal :read_only
     @pool.disconnect
     @max_size.must_equal 4
-    @pool.conn.must_equal nil
-    @pool.conn(:read_only).must_equal nil
+    @pool.conn.must_be_nil
+    @pool.conn(:read_only).must_be_nil
   end
 
   it ":disconnection_proc option should set the disconnection proc to use" do
@@ -1041,7 +1041,7 @@ AllConnectionPoolClassesSpecs = shared_description do
     x = nil
     c = @class.new(mock_db.call(proc{|c1| x = c1}){123})
     c.hold{}
-    x.must_equal nil
+    x.must_be_nil
     c.disconnect
     x.must_equal 123
   end

data/spec/core/database_spec.rb

@@ -79,127 +79,6 @@ describe "A new Database" do
     db.pool.must_be_kind_of(Sequel::ConnectionPool)
   end
 
-  it "should respect the :quote_identifiers option" do
-    db = Sequel::Database.new(:quote_identifiers=>false)
-    db.quote_identifiers?.must_equal false
-    db = Sequel::Database.new(:quote_identifiers=>true)
-    db.quote_identifiers?.must_equal true
-  end
-
-  it "should upcase on input and downcase on output by default" do
-    db = Sequel::Database.new
-    db.send(:identifier_input_method_default).must_equal :upcase
-    db.send(:identifier_output_method_default).must_equal :downcase
-  end
-
-  it "should respect the :identifier_input_method option" do
-    Sequel.identifier_input_method = nil
-    Sequel::Database.identifier_input_method.must_equal false
-    db = Sequel::Database.new(:identifier_input_method=>nil)
-    db.identifier_input_method.must_equal nil
-    db.identifier_input_method = :downcase
-    db.identifier_input_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_input_method=>:upcase)
-    db.identifier_input_method.must_equal :upcase
-    db.identifier_input_method = nil
-    db.identifier_input_method.must_equal nil
-    Sequel.identifier_input_method = :downcase
-    Sequel::Database.identifier_input_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_input_method=>nil)
-    db.identifier_input_method.must_equal nil
-    db.identifier_input_method = :upcase
-    db.identifier_input_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_input_method=>:upcase)
-    db.identifier_input_method.must_equal :upcase
-    db.identifier_input_method = nil
-    db.identifier_input_method.must_equal nil
-  end
-  
-  it "should respect the :identifier_output_method option" do
-    Sequel.identifier_output_method = nil
-    Sequel::Database.identifier_output_method.must_equal false
-    db = Sequel::Database.new(:identifier_output_method=>nil)
-    db.identifier_output_method.must_equal nil
-    db.identifier_output_method = :downcase
-    db.identifier_output_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_output_method=>:upcase)
-    db.identifier_output_method.must_equal :upcase
-    db.identifier_output_method = nil
-    db.identifier_output_method.must_equal nil
-    Sequel.identifier_output_method = :downcase
-    Sequel::Database.identifier_output_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_output_method=>nil)
-    db.identifier_output_method.must_equal nil
-    db.identifier_output_method = :upcase
-    db.identifier_output_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_output_method=>:upcase)
-    db.identifier_output_method.must_equal :upcase
-    db.identifier_output_method = nil
-    db.identifier_output_method.must_equal nil
-  end
-
-  it "should use the default Sequel.quote_identifiers value" do
-    Sequel.quote_identifiers = true
-    Sequel::Database.new({}).quote_identifiers?.must_equal true
-    Sequel.quote_identifiers = false
-    Sequel::Database.new({}).quote_identifiers?.must_equal false
-    Sequel::Database.quote_identifiers = true
-    Sequel::Database.new({}).quote_identifiers?.must_equal true
-    Sequel::Database.quote_identifiers = false
-    Sequel::Database.new({}).quote_identifiers?.must_equal false
-  end
-
-  it "should use the default Sequel.identifier_input_method value" do
-    Sequel.identifier_input_method = :downcase
-    Sequel::Database.new({}).identifier_input_method.must_equal :downcase
-    Sequel.identifier_input_method = :upcase
-    Sequel::Database.new({}).identifier_input_method.must_equal :upcase
-    Sequel::Database.identifier_input_method = :downcase
-    Sequel::Database.new({}).identifier_input_method.must_equal :downcase
-    Sequel::Database.identifier_input_method = :upcase
-    Sequel::Database.new({}).identifier_input_method.must_equal :upcase
-  end
-  
-  it "should use the default Sequel.identifier_output_method value" do
-    Sequel.identifier_output_method = :downcase
-    Sequel::Database.new({}).identifier_output_method.must_equal :downcase
-    Sequel.identifier_output_method = :upcase
-    Sequel::Database.new({}).identifier_output_method.must_equal :upcase
-    Sequel::Database.identifier_output_method = :downcase
-    Sequel::Database.new({}).identifier_output_method.must_equal :downcase
-    Sequel::Database.identifier_output_method = :upcase
-    Sequel::Database.new({}).identifier_output_method.must_equal :upcase
-  end
-
-  it "should respect the quote_indentifiers_default method if Sequel.quote_identifiers = nil" do
-    Sequel.quote_identifiers = nil
-    Sequel::Database.new({}).quote_identifiers?.must_equal true
-    x = Class.new(Sequel::Database){def quote_identifiers_default; false end}
-    x.new({}).quote_identifiers?.must_equal false
-    y = Class.new(Sequel::Database){def quote_identifiers_default; true end}
-    y.new({}).quote_identifiers?.must_equal true
-  end
-  
-  it "should respect the identifier_input_method_default method" do
-    class Sequel::Database
-      @identifier_input_method = nil
-    end
-    x = Class.new(Sequel::Database){def identifier_input_method_default; :downcase end}
-    x.new({}).identifier_input_method.must_equal :downcase
-    y = Class.new(Sequel::Database){def identifier_input_method_default; :camelize end}
-    y.new({}).identifier_input_method.must_equal :camelize
-  end
-  
-  it "should respect the identifier_output_method_default method if Sequel.identifier_output_method is not called" do
-    class Sequel::Database
-      @identifier_output_method = nil
-    end
-    x = Class.new(Sequel::Database){def identifier_output_method_default; :upcase end}
-    x.new({}).identifier_output_method.must_equal :upcase
-    y = Class.new(Sequel::Database){def identifier_output_method_default; :underscore end}
-    y.new({}).identifier_output_method.must_equal :underscore
-  end
-
   it "should just use a :uri option for jdbc with the full connection string" do
     db = Sequel::Database.stub(:adapter_class, Sequel::Database) do
       Sequel.connect('jdbc:test://host/db_name')
@@ -384,7 +263,7 @@ describe "Database#uri" do
   end
   
   it "should return nil if a connection uri was not used" do
-    Sequel.mock.uri.must_equal nil
+    Sequel.mock.uri.must_be_nil
   end
   
   it "should be aliased as #url" do
@@ -394,7 +273,7 @@ end
 
 describe "Database.adapter_scheme and #adapter_scheme" do
   it "should return the database scheme" do
-    Sequel::Database.adapter_scheme.must_equal nil
+    Sequel::Database.adapter_scheme.must_be_nil
 
     @c = Class.new(Sequel::Database) do
       set_adapter_scheme :mau
@@ -407,7 +286,7 @@ end
 
 describe "Database#dataset" do
   before do
-    @db = Sequel::Database.new
+    @db = Sequel.mock
     @ds = @db.dataset
   end
   
@@ -516,8 +395,11 @@ describe "Database#extend_datasets" do
   end
 
   it "should be able to override methods defined in the original Dataset class" do
-    @db.extend_datasets(Module.new{def select(*a, &block) super.order(*a, &block) end})
-    @db[:t].select(:a, :b).sql.must_equal 'SELECT a, b FROM t ORDER BY a, b'
+    @db.extend_datasets do
+      def select(*a, &block) super.order(*a, &block) end
+      def input_identifier(v) v.to_s end
+    end
+    @db[:t].with_quote_identifiers(false).select(:a, :b).sql.must_equal 'SELECT a, b FROM t ORDER BY a, b'
   end
 
   it "should reapply settings if dataset_class is changed" do
@@ -565,7 +447,7 @@ describe "Database#run" do
   end
   
   it "should return nil" do
-    @db.run("DELETE FROM items").must_equal nil
+    @db.run("DELETE FROM items").must_be_nil
   end
   
   it "should accept options passed to execute_ddl" do
@@ -609,7 +491,7 @@ describe "Database#synchronize" do
     c1.must_equal 12345
     t2 = Thread.new{@db.synchronize{|c| c2 = c; q2.push nil}}
     @db.pool.available_connections.must_be :empty?
-    c2.must_equal nil
+    c2.must_be_nil
     q1.push nil
     q.pop
     q2.pop
@@ -841,13 +723,13 @@ DatabaseTransactionSpecs = shared_description do
     rbc = nil
     @db.transaction do 
       rbc = @db.rollback_checker
-      rbc.call.must_equal nil
+      rbc.call.must_be_nil
     end
     rbc.call.must_equal false
 
     @db.transaction(:rollback=>:always) do 
       rbc = @db.rollback_checker
-      rbc.call.must_equal nil
+      rbc.call.must_be_nil
     end
     rbc.call.must_equal true
 
@@ -864,7 +746,7 @@ DatabaseTransactionSpecs = shared_description do
   end
   
   it "should return nil if Sequel::Rollback is called in the transaction" do
-    @db.transaction{raise Sequel::Rollback}.must_equal nil
+    @db.transaction{raise Sequel::Rollback}.must_be_nil
   end
   
   it "should reraise Sequel::Rollback errors when using :rollback=>:reraise option is given" do
@@ -879,7 +761,7 @@ DatabaseTransactionSpecs = shared_description do
   it "should always rollback if :rollback=>:always option is given" do
     proc {@db.transaction(:rollback=>:always){raise ArgumentError}}.must_raise(ArgumentError)
     @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
-    @db.transaction(:rollback=>:always){raise Sequel::Rollback}.must_equal nil
+    @db.transaction(:rollback=>:always){raise Sequel::Rollback}.must_be_nil
     @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
     @db.transaction(:rollback=>:always){1}.must_equal 1
     @db.sqls.must_equal ['BEGIN', 'ROLLBACK']
@@ -1158,7 +1040,7 @@ describe "Sequel.transaction" do
   end
   
   it "should handle Sequel::Rollback exceptions raised by the block to rollback on all databases" do
-    Sequel.transaction([@db1, @db2, @db3]){raise Sequel::Rollback}.must_equal nil
+    Sequel.transaction([@db1, @db2, @db3]){raise Sequel::Rollback}.must_be_nil
     @sqls.must_equal ['BEGIN -- 1', 'BEGIN -- 2', 'BEGIN -- 3', 'ROLLBACK -- 3', 'ROLLBACK -- 2', 'ROLLBACK -- 1']
   end
   
@@ -1465,7 +1347,7 @@ end
 
 describe "Sequel::Database.load_adapter" do
   it "should not raise an error if subadapter does not exist" do
-    Sequel::Database.load_adapter(:foo, :subdir=>'bar').must_equal nil
+    Sequel::Database.load_adapter(:foo, :subdir=>'bar').must_be_nil
   end
 end
 
@@ -1617,7 +1499,7 @@ describe "Database#fetch" do
     ds.select_sql.must_equal 'select * from xyz'
     ds.sql.must_equal 'select * from xyz'
     
-    ds.filter!{price.sql_number < 100}
+    ds = ds.where{price.sql_number < 100}
     ds.select_sql.must_equal 'select * from xyz'
     ds.sql.must_equal 'select * from xyz'
   end
@@ -1950,7 +1832,7 @@ describe "Database#typecast_value" do
     @db.typecast_value(:boolean, '1').must_equal true
     @db.typecast_value(:boolean, 't').must_equal true
     @db.typecast_value(:boolean, 'true').must_equal true
-    @db.typecast_value(:boolean, '').must_equal nil
+    @db.typecast_value(:boolean, '').must_be_nil
   end
 
   it "should typecast date values to Date" do
@@ -2405,37 +2287,11 @@ describe "Database#supports_transaction_isolation_levels?" do
   end
 end
 
-describe "Database#input_identifier_meth" do
-  it "should be the input_identifer method of a default dataset for this database" do
-    db = Sequel::Database.new
-    db.send(:input_identifier_meth).call(:a).must_equal 'a'
-    db.identifier_input_method = :upcase
-    db.send(:input_identifier_meth).call(:a).must_equal 'A'
-  end
-end
-
-describe "Database#output_identifier_meth" do
-  it "should be the output_identifer method of a default dataset for this database" do
-    db = Sequel::Database.new
-    db.send(:output_identifier_meth).call('A').must_equal :A
-    db.identifier_output_method = :downcase
-    db.send(:output_identifier_meth).call('A').must_equal :a
-  end
-end
-
-describe "Database#metadata_dataset" do
-  it "should be a dataset with the default settings for identifier_input_method and identifier_output_method" do
-    ds = Sequel::Database.new.send(:metadata_dataset)
-    ds.literal(:a).must_equal 'A'
-    ds.send(:output_identifier, 'A').must_equal :a
-  end
-end
-
 describe "Database#column_schema_to_ruby_default" do
   it "should handle converting many default formats" do
     db = Sequel::Database.new
     p = lambda{|d,t| db.send(:column_schema_to_ruby_default, d, t)}
-    p[nil, :integer].must_equal nil
+    p[nil, :integer].must_be_nil
     p[1, :integer].must_equal 1
     p['1', :integer].must_equal 1
     p['-1', :integer].must_equal(-1)
@@ -2471,7 +2327,7 @@ describe "Database#column_schema_to_ruby_default" do
     p["'2009-10-29T10:20:30-07:00'", :datetime].must_equal DateTime.parse('2009-10-29T10:20:30-07:00')
     p["'2009-10-29 10:20:30'", :datetime].must_equal DateTime.parse('2009-10-29 10:20:30')
     p["'10:20:30'", :time].must_equal Time.parse('10:20:30')
-    p["NaN", :float].must_equal nil
+    p["NaN", :float].must_be_nil
 
     db = Sequel.mock(:host=>'postgres')
     p["''::text", :string].must_equal ""
@@ -2523,7 +2379,7 @@ describe "Database extensions" do
     end
   end
   before do
-    @db = Sequel.mock
+    @db = Sequel.mock(:identifier_mangling=>false)
   end
   after do
     Sequel::Database.instance_variable_set(:@initialize_hook, Proc.new {|db| })
@@ -2535,25 +2391,21 @@ describe "Database extensions" do
   end
 
   it "should be able to register an extension with a block and have Database#extension call the block" do
-    @db.quote_identifiers = false
-    Sequel::Database.register_extension(:foo){|db| db.quote_identifiers = true}
-    @db.extension(:foo).quote_identifiers?.must_equal true
+    Sequel::Database.register_extension(:foo){|db| db.opts[:foo] = 1}
+    @db.extension(:foo).opts[:foo].must_equal 1
   end
 
   it "should be able to register an extension with a callable and Database#extension call the callable" do
-    @db.quote_identifiers = false
-    Sequel::Database.register_extension(:foo, proc{|db| db.quote_identifiers = true})
-    @db.extension(:foo).quote_identifiers?.must_equal true
+    Sequel::Database.register_extension(:foo, proc{|db| db.opts[:foo] = 1})
+    @db.extension(:foo).opts[:foo].must_equal 1
   end
 
   it "should be able to load multiple extensions in the same call" do
-    @db.quote_identifiers = false
-    @db.identifier_input_method = :downcase
-    Sequel::Database.register_extension(:foo, proc{|db| db.quote_identifiers = true})
-    Sequel::Database.register_extension(:bar, proc{|db| db.identifier_input_method = nil})
-    @db.extension(:foo, :bar)
-    @db.quote_identifiers?.must_equal true
-    @db.identifier_input_method.must_equal nil
+    a = []
+    Sequel::Database.register_extension(:foo, proc{|db| a << db.opts[:foo] = 1})
+    Sequel::Database.register_extension(:bar, proc{|db| a << db.opts[:bar] = 2})
+    @db.extension(:foo, :bar).opts.values_at(:foo, :bar).must_equal [1, 2]
+    a.must_equal [1, 2]
   end
 
   it "should return the receiver" do
@@ -2575,8 +2427,8 @@ describe "Database extensions" do
     Sequel::Database.extension(:foo, :bar)
     @db.wont_respond_to(:a)
     @db.wont_respond_to(:b)
-    Sequel.mock.a.must_equal 1
-    Sequel.mock.b.must_equal 2
+    Sequel.mock(:identifier_mangling=>false).a.must_equal 1
+    Sequel.mock(:identifier_mangling=>false).b.must_equal 2
   end
 end
 
@@ -2664,3 +2516,9 @@ describe "Database#execute_{dui,ddl,insert}" do
     @db.sqls.must_equal ["DELETE FROM table", "SET foo", "INSERT INTO table DEFAULT VALUES"]
   end
 end
+
+describe "Dataset identifier folding" do
+  it "should fold to uppercase by default, as per SQL" do
+    Sequel::Database.new(:identifier_mangling=>false).send(:folds_unquoted_identifiers_to_uppercase?).must_equal true
+  end
+end