sequel 4.44.0 → 4.45.0

data/spec/extensions/association_proxies_spec.rb

@@ -44,13 +44,13 @@ describe "Sequel::Plugins::AssociationProxies" do
       proxy_block = opts[:proxy_block]
       cached = opts[:instance].associations[opts[:reflection][:name]]
       is_size = opts[:method] == :size
-      is_size && !cached && !proxy_arg && !proxy_block
+      is_size && !cached && !proxy_arg[:reload] && !proxy_block
     end
     @t.size.must_equal 1
     Item.db.sqls.must_equal ["SELECT count(*) AS count FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE (items_tags.item_id = 1) LIMIT 1"]
     @i.tags{|ds| ds}.size.must_equal 1
     Item.db.sqls.must_equal ["SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE (items_tags.item_id = 1)"]
-    @i.tags(true).size.must_equal 1
+    @i.tags(:reload=>true).size.must_equal 1
     Item.db.sqls.must_equal ["SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE (items_tags.item_id = 1)"]
     @t.size.must_equal 1
     Item.db.sqls.must_equal []
@@ -61,7 +61,7 @@ describe "Sequel::Plugins::AssociationProxies" do
     Item.db.sqls.length.must_equal 1
     @t.select{|x| false}.must_equal []
     Item.db.sqls.length.must_equal 0
-    @i.tags(true).select{|x| false}.must_equal []
+    @i.tags(:reload=>true).select{|x| false}.must_equal []
     Item.db.sqls.length.must_equal 1
     @t.filter(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
     Item.db.sqls.length.must_equal 0

data/spec/extensions/class_table_inheritance_spec.rb

@@ -457,3 +457,42 @@ describe "class_table_inheritance plugin without sti_key" do
     @db.sqls.must_equal ['SELECT employees.id, employees.name, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id) WHERE (staff.manager_id = 3)']
   end
 end
+
+describe "class_table_inheritance plugin with duplicate columns" do
+  before do
+    @db = Sequel.mock(:autoid=>proc{|sql| 1})
+    def @db.supports_schema_parsing?() true end
+    def @db.schema(table, opts={})
+      {:employees=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string}], [:kind, {:type=>:string}]],
+       :managers=>[[:id, {:type=>:integer}], [:name, {:type=>:string}]],
+       }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
+    end
+    @db.extend_datasets do
+      def columns
+        {[:employees]=>[:id, :name, :kind],
+         [:managers]=>[:id, :name],
+        }[opts[:from] + (opts[:join] || []).map{|x| x.table}]
+      end
+    end
+    class ::Employee < Sequel::Model(@db)
+      def _save_refresh; @values[:id] = 1 end
+      def self.columns
+        dataset.columns
+      end
+      plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff}
+    end 
+    deprecated do
+    class ::Manager < Employee; end
+    end
+    @ds = Employee.dataset
+    @db.sqls
+  end
+  after do
+    Object.send(:remove_const, :Manager)
+    Object.send(:remove_const, :Employee)
+  end
+
+  it "should select names from both tables" do
+    Manager.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, managers.name FROM employees INNER JOIN managers ON (managers.id = employees.id)'
+  end
+end

data/spec/extensions/columns_updated_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::ColumnsUpdated" do
+  before do
+    @c = Class.new(Sequel::Model(DB[:items].with_autoid(13)))
+    @c.columns :id, :x, :y
+    @c.plugin :columns_updated
+  end
+  
+  it "should make hash used for updating available in columns_updated until after hooks finish running" do
+    res = nil
+    @c.send(:define_method, :after_save){res = columns_updated}
+    o = @c.new(:x => 1, :y => nil)
+    o[:x] = 2
+    o.save
+    res.must_be_nil
+    o.after_save
+    res.must_be_nil
+
+    o = @c.load(:id => 23,:x => 1, :y => nil)
+    o[:x] = 2
+    o.save
+    res.must_equal(:x=>2, :y=>nil)
+    o.after_save
+    res.must_be_nil
+
+    o = @c.load(:id => 23,:x => 2, :y => nil)
+    o[:x] = 2
+    o[:y] = 22
+    o.save(:columns=>:x)
+    res.must_equal(:x=>2)
+    o.after_save
+    res.must_be_nil
+  end
+end

data/spec/extensions/composition_spec.rb

@@ -9,6 +9,12 @@ describe "Composition plugin" do
     DB.reset
   end
   
+  deprecated "should allow access to composition_module" do
+    @c.composition_module.must_be_kind_of Module
+    @c.composition_module = v = Module.new
+    @c.composition_module.must_equal v
+  end
+
   it ".composition should add compositions" do
     @o.wont_respond_to(:date)
     @c.composition :date, :mapping=>[:year, :month, :day]
@@ -247,6 +253,5 @@ describe "Composition plugin" do
     @c.freeze
     @c.compositions.frozen?.must_equal true
     @c.compositions[:date].frozen?.must_equal true
-    @c.composition_module.frozen?.must_equal true
   end
 end

data/spec/extensions/hook_class_methods_spec.rb

@@ -140,7 +140,7 @@ describe Sequel::Model, "hook_class_methods plugin" do
     adds.must_equal ['456']
   end
   
-  it "should stop processing if a before hook returns false" do
+  deprecated "should stop processing if a before hook returns false" do
     flag = true
     adds = []
     
@@ -172,6 +172,40 @@ describe Sequel::Model, "hook_class_methods plugin" do
     b.new.before_save
     adds.must_equal ['mau', 'blah']
   end
+
+  it "should stop processing if a before hook calls cancel_action" do
+    flag = true
+    adds = []
+    
+    a = model_class.call Sequel::Model(:items) do
+      before_save{adds << 'cruel'; cancel_action if flag == false}
+      before_save{adds << 'blah'; cancel_action if flag == false}
+    end
+    
+    a.raise_on_save_failure = false
+    a.new.save
+    adds.must_equal ['blah', 'cruel']
+
+    # chain should not break on nil
+    adds = []
+    flag = nil
+    a.new.save
+    adds.must_equal ['blah', 'cruel']
+    
+    adds = []
+    flag = false
+    a.new.save
+    adds.must_equal ['blah']
+    
+    b = Class.new(a)
+    b.class_eval do
+      before_save{adds << 'mau'}
+    end
+    
+    adds = []
+    b.new.save
+    adds.must_equal ['mau', 'blah']
+  end
 end
 
 describe "Model#before_create && Model#after_create" do
@@ -192,7 +226,7 @@ describe "Model#before_create && Model#after_create" do
     DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
   end
 
-  it ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
+  deprecated ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
     @c.before_create{false}
     proc{@c.create(:x => 2)}.must_raise(Sequel::HookFailed)
     DB.sqls.must_equal []
@@ -204,7 +238,7 @@ describe "Model#before_create && Model#after_create" do
     DB.sqls.must_equal []
   end
 
-  it ".create should cancel the save and return nil if before_create returns false and raise_on_save_failure is false" do
+  deprecated ".create should cancel the save and return nil if before_create returns false and raise_on_save_failure is false" do
     @c.before_create{false}
     @c.raise_on_save_failure = false
     @c.create(:x => 2).must_be_nil
@@ -235,18 +269,31 @@ describe "Model#before_update && Model#after_update" do
     DB.sqls.must_equal ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
 
-  it "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
+  deprecated "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
     @c.before_update{false}
     proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
     DB.sqls.must_equal []
   end
 
-  it "#save should cancel the save and return nil if before_update returns false and raise_on_save_failure is false" do
+  it "#save should cancel the save and raise an error if before_update calls cancel_action and raise_on_save_failure is true" do
+    @c.before_update{cancel_action}
+    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
+  end
+
+  deprecated "#save should cancel the save and return nil if before_update returns false and raise_on_save_failure is false" do
     @c.before_update{false}
     @c.raise_on_save_failure = false
     @c.load(:id => 2233).save.must_be_nil
     DB.sqls.must_equal []
   end
+
+  it "#save should cancel the save and return nil if before_update calls cancel_action and raise_on_save_failure is false" do
+    @c.before_update{cancel_action}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).save.must_be_nil
+    DB.sqls.must_equal []
+  end
 end
 
 describe "Model#before_save && Model#after_save" do
@@ -273,18 +320,31 @@ describe "Model#before_save && Model#after_save" do
     DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
   end
 
-  it "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
+  deprecated "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
     @c.before_save{false}
     proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
     DB.sqls.must_equal []
   end
 
-  it "#save should cancel the save and return nil if before_save returns false and raise_on_save_failure is false" do
+  it "#save should cancel the save and raise an error if before_save calls cancel_action and raise_on_save_failure is true" do
+    @c.before_save{cancel_action}
+    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
+  end
+
+  deprecated "#save should cancel the save and return nil if before_save returns false and raise_on_save_failure is false" do
     @c.before_save{false}
     @c.raise_on_save_failure = false
     @c.load(:id => 2233).save.must_be_nil
     DB.sqls.must_equal []
   end
+
+  it "#save should cancel the save and return nil if before_save calls cancel_action and raise_on_save_failure is false" do
+    @c.before_save{cancel_action}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).save.must_be_nil
+    DB.sqls.must_equal []
+  end
 end
 
 describe "Model#before_destroy && Model#after_destroy" do
@@ -303,18 +363,31 @@ describe "Model#before_destroy && Model#after_destroy" do
     DB.sqls.must_equal ['BLAH before', "DELETE FROM items WHERE id = 2233", 'BLAH after']
   end
 
-  it "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
+  deprecated "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
     @c.before_destroy{false}
     proc{@c.load(:id => 2233).destroy}.must_raise(Sequel::HookFailed)
     DB.sqls.must_equal []
   end
 
-  it "#destroy should cancel the destroy and return nil if before_destroy returns false and raise_on_save_failure is false" do
+  it "#destroy should cancel the destroy and raise an error if before_destroy calls cancel_action and raise_on_save_failure is true" do
+    @c.before_destroy{cancel_action}
+    proc{@c.load(:id => 2233).destroy}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
+  end
+
+  deprecated "#destroy should cancel the destroy and return nil if before_destroy returns false and raise_on_save_failure is false" do
     @c.before_destroy{false}
     @c.raise_on_save_failure = false
     @c.load(:id => 2233).destroy.must_be_nil
     DB.sqls.must_equal []
   end
+
+  it "#destroy should cancel the destroy and return nil if before_destroy calls cancel_action and raise_on_save_failure is false" do
+    @c.before_destroy{cancel_action}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).destroy.must_be_nil
+    DB.sqls.must_equal []
+  end
 end
 
 describe "Model#before_validation && Model#after_validation" do
@@ -357,18 +430,31 @@ describe "Model#before_validation && Model#after_validation" do
     DB.sqls.must_equal ['BLAH before', 'BLAH after']
   end
 
-  it "#save should cancel the save and raise an error if before_validation returns false and raise_on_save_failure is true" do
+  deprecated "#save should cancel the save and raise an error if before_validation returns false and raise_on_save_failure is true" do
     @c.before_validation{false}
     proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
     DB.sqls.must_equal []
   end
 
-  it "#save should cancel the save and return nil if before_validation returns false and raise_on_save_failure is false" do
+  it "#save should cancel the save and raise an error if before_validation calls cancel_action and raise_on_save_failure is true" do
+    @c.before_validation{cancel_action}
+    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
+  end
+
+  deprecated "#save should cancel the save and return nil if before_validation returns false and raise_on_save_failure is false" do
     @c.before_validation{false}
     @c.raise_on_save_failure = false
     @c.load(:id => 2233).save.must_be_nil
     DB.sqls.must_equal []
   end
+
+  it "#save should cancel the save and return nil if before_validation calls cancel_action and raise_on_save_failure is false" do
+    @c.before_validation{cancel_action}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).save.must_be_nil
+    DB.sqls.must_equal []
+  end
 end
 
 describe "Model transaction hooks" do
@@ -383,7 +469,7 @@ describe "Model transaction hooks" do
     end
   end
   
-  it "should call after_commit or after_rollback depending on whether the transaction commits or rolls back" do
+  deprecated "should call after_commit or after_rollback depending on whether the transaction commits or rolls back" do
     @c.after_commit{DB << 'AC'}
     @c.after_rollback{DB << 'AR'}
     m = @c.load(:id => 2233, :x=>123)
@@ -400,7 +486,7 @@ describe "Model transaction hooks" do
     end
   end
   
-  it "should call after_destroy_commit or after_destroy_rollback depending on whether the transaction commits or rolls back" do
+  deprecated "should call after_destroy_commit or after_destroy_rollback depending on whether the transaction commits or rolls back" do
     @c.after_destroy_commit {DB << 'ADC'}
     @c.after_destroy_rollback{DB << 'ADR'}
 
@@ -439,33 +525,35 @@ end
 
 describe "Model#add_hook_type" do
   before do
-    class ::Foo < Sequel::Model(:items)
-      plugin :hook_class_methods
-      add_hook_type :before_bar, :after_bar
-
-      def bar
-        return :b if before_bar == false
-        return :a if after_bar == false
-        true
+    deprecated do
+      class ::Foo < Sequel::Model(:items)
+        plugin :hook_class_methods
+        add_hook_type :before_bar, :after_bar
+
+        def bar
+          return :b if before_bar == false
+          return :a if after_bar == false
+          true
+        end
       end
+      @f = Class.new(Foo)
     end
-    @f = Class.new(Foo)
   end
   after do
     Object.send(:remove_const, :Foo)
   end
 
-  it "should have before_bar and after_bar class methods" do
+  deprecated "should have before_bar and after_bar class methods" do
     @f.must_respond_to(:before_bar)
     @f.must_respond_to(:before_bar)
   end
 
-  it "should have before_bar and after_bar instance methods" do
+  deprecated "should have before_bar and after_bar instance methods" do
     @f.new.must_respond_to(:before_bar)
     @f.new.must_respond_to(:before_bar)
   end
 
-  it "it should return true for bar when before_bar and after_bar hooks are returing true" do
+  deprecated "it should return true for bar when before_bar and after_bar hooks are returing true" do
     a = 1
     @f.before_bar { a += 1}
     @f.new.bar.must_equal true
@@ -475,7 +563,7 @@ describe "Model#add_hook_type" do
     a.must_equal 6
   end
 
-  it "it should return nil for bar when before_bar and after_bar hooks are returing false" do
+  deprecated "it should return nil for bar when before_bar and after_bar hooks are returing false" do
     @f.new.bar.must_equal true
     @f.after_bar { false }
     @f.new.bar.must_equal :a

data/spec/extensions/identifier_mangling_spec.rb

@@ -2,117 +2,149 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "identifier_mangling extension" do
   after do
-    Sequel.quote_identifiers = false
-    Sequel.identifier_input_method = nil
-    Sequel.identifier_output_method = nil
+    deprecated do
+      Sequel.quote_identifiers = false
+      Sequel.identifier_input_method = nil
+      Sequel.identifier_output_method = nil
+    end
   end
   
   it "should respect the :quote_identifiers option" do
-    db = Sequel::Database.new(:quote_identifiers=>false, :identifier_mangling=>true)
+    db = Sequel::Database.new(:quote_identifiers=>false).extension(:identifier_mangling)
     db.quote_identifiers?.must_equal false
-    db = Sequel::Database.new(:quote_identifiers=>true, :identifier_mangling=>true)
+    db = Sequel::Database.new(:quote_identifiers=>true).extension(:identifier_mangling)
     db.quote_identifiers?.must_equal true
   end
 
   it "should respect the :quote_identifiers setting" do
-    db = Sequel::Database.new(:identifier_mangling=>true)
+    db = Sequel::Database.new.extension(:identifier_mangling)
     db.quote_identifiers?.must_equal false
     db.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(:identifier_mangling=>true)
+    db = Sequel::Database.new.extension(:identifier_mangling)
     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, :identifier_mangling=>true)
+    db = Sequel::Database.new.extension(:identifier_mangling)
     db.identifier_input_method.must_be_nil
     db.identifier_input_method = :downcase
     db.identifier_input_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_input_method=>:upcase, :identifier_mangling=>true)
+    db = Sequel::Database.new(:identifier_input_method=>nil).extension(:identifier_mangling)
+    db.identifier_input_method.must_be_nil
+    db.identifier_input_method = :downcase
+    db.identifier_input_method.must_equal :downcase
+    db = Sequel::Database.new(:identifier_input_method=>:upcase).extension(:identifier_mangling)
     db.identifier_input_method.must_equal :upcase
     db.identifier_input_method = nil
     db.identifier_input_method.must_be_nil
+  end
+  
+  deprecated "should default to Sequel.identifier_input_method" do
     Sequel.identifier_input_method = :downcase
     Sequel::Database.identifier_input_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_input_method=>nil, :identifier_mangling=>true)
+    db = Sequel::Database.new.extension(:identifier_mangling)
+    db.identifier_input_method.must_equal :downcase
+    db.identifier_input_method = :upcase
+    db.identifier_input_method.must_equal :upcase
+    db = Sequel::Database.new(:identifier_input_method=>nil).extension(:identifier_mangling)
     db.identifier_input_method.must_be_nil
     db.identifier_input_method = :upcase
     db.identifier_input_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_input_method=>:upcase, :identifier_mangling=>true)
+    db = Sequel::Database.new(:identifier_input_method=>:upcase).extension(:identifier_mangling)
     db.identifier_input_method.must_equal :upcase
     db.identifier_input_method = nil
     db.identifier_input_method.must_be_nil
+    Sequel.identifier_input_method = nil
+    Sequel::Database.identifier_input_method.must_equal false
+    db = Sequel::Database.new.extension(:identifier_mangling)
+    db.identifier_input_method.must_be_nil
+    db.identifier_input_method = :upcase
+    db.identifier_input_method.must_equal :upcase
   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, :identifier_mangling=>true)
+    db = Sequel::Database.new.extension(:identifier_mangling)
+    db.identifier_output_method.must_be_nil
+    db.identifier_output_method = :upcase
+    db.identifier_output_method.must_equal :upcase
+    db = Sequel::Database.new(:identifier_output_method=>nil).extension(:identifier_mangling)
     db.identifier_output_method.must_be_nil
     db.identifier_output_method = :downcase
     db.identifier_output_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_output_method=>:upcase, :identifier_mangling=>true)
+    db = Sequel::Database.new(:identifier_output_method=>:upcase).extension(:identifier_mangling)
     db.identifier_output_method.must_equal :upcase
     db.identifier_output_method = nil
     db.identifier_output_method.must_be_nil
-    Sequel.identifier_output_method = :downcase
-    Sequel::Database.identifier_output_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_output_method=>nil, :identifier_mangling=>true)
-    db.identifier_output_method.must_be_nil
-    db.identifier_output_method = :upcase
+  end
+
+  deprecated "should default to Sequel.identifier_output_method" do
+    Sequel.identifier_output_method = :upcase
+    Sequel::Database.identifier_output_method.must_equal :upcase
+    db = Sequel::Database.new.extension(:identifier_mangling)
     db.identifier_output_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_output_method=>:upcase, :identifier_mangling=>true)
+    db.identifier_output_method = :downcase
+    db.identifier_output_method.must_equal :downcase
+    db = Sequel::Database.new(:identifier_output_method=>nil).extension(:identifier_mangling)
+    db.identifier_output_method.must_be_nil
+    db.identifier_output_method = :downcase
+    db.identifier_output_method.must_equal :downcase
+    db = Sequel::Database.new(:identifier_output_method=>:upcase).extension(:identifier_mangling)
     db.identifier_output_method.must_equal :upcase
     db.identifier_output_method = nil
     db.identifier_output_method.must_be_nil
+    Sequel.identifier_output_method = nil
+    Sequel::Database.identifier_output_method.must_equal false
+    db = Sequel::Database.new.extension(:identifier_mangling)
+    db.identifier_output_method.must_be_nil
+    db.identifier_output_method = :downcase
+    db.identifier_output_method.must_equal :downcase
   end
 
-  it "should use the default Sequel.quote_identifiers value" do
+  deprecated "should use the default Sequel.quote_identifiers value" do
     Sequel.quote_identifiers = true
-    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
+    Sequel::Database.new.extension(:identifier_mangling).quote_identifiers?.must_equal true
     Sequel.quote_identifiers = false
-    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal false
+    Sequel::Database.new.extension(:identifier_mangling).quote_identifiers?.must_equal false
     Sequel::Database.quote_identifiers = true
-    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
+    Sequel::Database.new.extension(:identifier_mangling).quote_identifiers?.must_equal true
     Sequel::Database.quote_identifiers = false
-    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal false
+    Sequel::Database.new.extension(:identifier_mangling).quote_identifiers?.must_equal false
   end
 
-  it "should use the default Sequel.identifier_input_method value" do
+  deprecated "should use the default Sequel.identifier_input_method value" do
     Sequel.identifier_input_method = :downcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :downcase
+    Sequel::Database.new.extension(:identifier_mangling).identifier_input_method.must_equal :downcase
     Sequel.identifier_input_method = :upcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :upcase
+    Sequel::Database.new.extension(:identifier_mangling).identifier_input_method.must_equal :upcase
     Sequel::Database.identifier_input_method = :downcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :downcase
+    Sequel::Database.new.extension(:identifier_mangling).identifier_input_method.must_equal :downcase
     Sequel::Database.identifier_input_method = :upcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :upcase
+    Sequel::Database.new.extension(:identifier_mangling).identifier_input_method.must_equal :upcase
   end
   
-  it "should use the default Sequel.identifier_output_method value" do
+  deprecated "should use the default Sequel.identifier_output_method value" do
     Sequel.identifier_output_method = :downcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :downcase
+    Sequel::Database.new.extension(:identifier_mangling).identifier_output_method.must_equal :downcase
     Sequel.identifier_output_method = :upcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :upcase
+    Sequel::Database.new.extension(:identifier_mangling).identifier_output_method.must_equal :upcase
     Sequel::Database.identifier_output_method = :downcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :downcase
+    Sequel::Database.new.extension(:identifier_mangling).identifier_output_method.must_equal :downcase
     Sequel::Database.identifier_output_method = :upcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :upcase
+    Sequel::Database.new.extension(:identifier_mangling).identifier_output_method.must_equal :upcase
   end
 
-  it "should respect the quote_indentifiers_default method if Sequel.quote_identifiers = nil" do
+  deprecated "should respect the quote_indentifiers_default method if Sequel.quote_identifiers = nil" do
     Sequel.quote_identifiers = nil
-    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
+    Sequel::Database.new.extension(:identifier_mangling).quote_identifiers?.must_equal true
     x = Class.new(Sequel::Database){def quote_identifiers_default; false end}
-    x.new(:identifier_mangling=>true).quote_identifiers?.must_equal false
+    x.new.extension(:identifier_mangling).quote_identifiers?.must_equal false
     y = Class.new(Sequel::Database){def quote_identifiers_default; true end}
-    y.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
+    y.new.extension(:identifier_mangling).quote_identifiers?.must_equal true
   end
   
   it "should respect the identifier_input_method_default method if Sequel.identifier_input_method is not called" do
@@ -120,9 +152,9 @@ describe "identifier_mangling extension" do
       @identifier_input_method = nil
     end
     x = Class.new(Sequel::Database){def identifier_input_method_default; :downcase end}
-    x.new(:identifier_mangling=>true).identifier_input_method.must_equal :downcase
+    x.new.extension(:identifier_mangling).identifier_input_method.must_equal :downcase
     y = Class.new(Sequel::Database){def identifier_input_method_default; :camelize end}
-    y.new(:identifier_mangling=>true).identifier_input_method.must_equal :camelize
+    y.new.extension(:identifier_mangling).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
@@ -130,15 +162,15 @@ describe "identifier_mangling extension" do
       @identifier_output_method = nil
     end
     x = Class.new(Sequel::Database){def identifier_output_method_default; :upcase end}
-    x.new(:identifier_mangling=>true).identifier_output_method.must_equal :upcase
+    x.new.extension(:identifier_mangling).identifier_output_method.must_equal :upcase
     y = Class.new(Sequel::Database){def identifier_output_method_default; :underscore end}
-    y.new(:identifier_mangling=>true).identifier_output_method.must_equal :underscore
+    y.new.extension(:identifier_mangling).identifier_output_method.must_equal :underscore
   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(:identifier_mangling=>true)
+    db = Sequel::Database.new.extension(:identifier_mangling)
     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'
@@ -147,7 +179,7 @@ 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(:identifier_mangling=>true)
+    db = Sequel::Database.new.extension(:identifier_mangling)
     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
@@ -156,7 +188,7 @@ end
 
 describe "Database#metadata_dataset" do
   it "should be a dataset with the default settings for identifier_mangling" do
-    ds = Sequel::Database.new(:identifier_mangling=>true).send(:metadata_dataset)
+    ds = Sequel::Database.new.extension(:identifier_mangling).send(:metadata_dataset)
     ds.literal(:a).must_equal 'A'
     ds.send(:output_identifier, 'A').must_equal :a
   end
@@ -164,40 +196,40 @@ end
 
 describe "Dataset" do
   before do
-    @dataset = Sequel.mock(:identifier_mangling=>true).dataset
+    @dataset = Sequel.mock.extension(:identifier_mangling).dataset
   end
   
   it "should get quote_identifiers default from database" do
-    db = Sequel::Database.new(:quote_identifiers=>true, :identifier_mangling=>true)
+    db = Sequel::Database.new(:quote_identifiers=>true).extension(:identifier_mangling)
     db[:a].quote_identifiers?.must_equal true
-    db = Sequel::Database.new(:quote_identifiers=>false, :identifier_mangling=>true)
+    db = Sequel::Database.new(:quote_identifiers=>false).extension(:identifier_mangling)
     db[:a].quote_identifiers?.must_equal false
   end
 
   it "should get identifier_input_method default from database" do
-    db = Sequel::Database.new(:identifier_input_method=>:upcase, :identifier_mangling=>true)
+    db = Sequel::Database.new(:identifier_input_method=>:upcase).extension(:identifier_mangling)
     db[:a].identifier_input_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_input_method=>:downcase, :identifier_mangling=>true)
+    db = Sequel::Database.new(:identifier_input_method=>:downcase).extension(:identifier_mangling)
     db[:a].identifier_input_method.must_equal :downcase
   end
 
   it "should get identifier_output_method default from database" do
-    db = Sequel::Database.new(:identifier_output_method=>:upcase, :identifier_mangling=>true)
+    db = Sequel::Database.new(:identifier_output_method=>:upcase).extension(:identifier_mangling)
     db[:a].identifier_output_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_output_method=>:downcase, :identifier_mangling=>true)
+    db = Sequel::Database.new(:identifier_output_method=>:downcase).extension(:identifier_mangling)
     db[:a].identifier_output_method.must_equal :downcase
   end
   
   # SEQUEL5: Remove
   unless Sequel.mock(:identifier_mangling=>true).dataset.frozen?
-    it "should have quote_identifiers= method which changes literalization of identifiers" do
+    deprecated "should have quote_identifiers= method which changes literalization of identifiers" do
       @dataset.quote_identifiers = true
       @dataset.literal(:a).must_equal '"a"'
       @dataset.quote_identifiers = false
       @dataset.literal(:a).must_equal 'a'
     end
     
-    it "should have identifier_input_method= method which changes literalization of identifiers" do
+    deprecated "should have identifier_input_method= method which changes literalization of identifiers" do
       @dataset.identifier_input_method = :upcase
       @dataset.literal(:a).must_equal 'A'
       @dataset.identifier_input_method = :downcase
@@ -206,7 +238,7 @@ describe "Dataset" do
       @dataset.literal(:at_b).must_equal 'b_ta'
     end
     
-    it "should have identifier_output_method= method which changes identifiers returned from the database" do
+    deprecated "should have identifier_output_method= method which changes identifiers returned from the database" do
       @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_C
       @dataset.identifier_output_method = :upcase
       @dataset.send(:output_identifier, "at_b_C").must_equal :AT_B_C
@@ -257,7 +289,7 @@ describe "Frozen Datasets" do
     @ds = Sequel.mock(:identifier_mangling=>true)[:test].freeze
   end
 
-  it "should raise an error when calling mutation methods" do
+  deprecated "should raise an error when calling mutation methods" do
     proc{@ds.identifier_input_method = :a}.must_raise RuntimeError
     proc{@ds.identifier_output_method = :a}.must_raise RuntimeError
     proc{@ds.quote_identifiers = false}.must_raise RuntimeError
@@ -267,17 +299,17 @@ end
 describe "identifier_mangling extension" do
   it "should be able to load dialects based on the database name" do
     begin
-      qi = class Sequel::Database; @quote_identifiers; end
-      ii = class Sequel::Database; @identifier_input_method; end
-      io = class Sequel::Database; @identifier_output_method; end
-      Sequel.quote_identifiers = nil
-      class Sequel::Database; @identifier_input_method=nil; end
-      class Sequel::Database; @identifier_output_method=nil; end
+      qi, ii, io = nil
+      deprecated do
+        qi = class Sequel::Database; @quote_identifiers; end
+        ii = class Sequel::Database; @identifier_input_method; end
+        io = class Sequel::Database; @identifier_output_method; end
+        Sequel.quote_identifiers = nil
+        class Sequel::Database; @identifier_input_method=nil; end
+        class Sequel::Database; @identifier_output_method=nil; end
+      end
       Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.must_equal 'SELECT #2011-12-13#'
-      Sequel.mock(:host=>'cubrid').from(:a).offset(1).sql.must_equal 'SELECT * FROM "a" LIMIT 1,4294967295'
       Sequel.mock(:host=>'db2').select(1).sql.must_equal 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
-      Sequel.mock(:host=>'firebird')[:a].distinct.limit(1, 2).sql.must_equal 'SELECT DISTINCT FIRST 1 SKIP 2 * FROM "A"'
-      Sequel.mock(:host=>'informix')[:a].distinct.limit(1, 2).sql.must_equal 'SELECT SKIP 2 FIRST 1 DISTINCT * FROM A'
       Sequel.mock(:host=>'mssql')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM [A] WHERE (CONTAINS ([B], 'c'))"
       Sequel.mock(:host=>'mysql')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM `a` WHERE (MATCH (`b`) AGAINST ('c'))"
       Sequel.mock(:host=>'oracle')[:a].limit(1).sql.must_equal 'SELECT * FROM (SELECT * FROM "A") "T1" WHERE (ROWNUM <= 1)'
@@ -285,16 +317,18 @@ describe "identifier_mangling extension" do
       Sequel.mock(:host=>'sqlanywhere').from(:a).offset(1).sql.must_equal 'SELECT TOP 2147483647 START AT (1 + 1) * FROM "A"'
       Sequel.mock(:host=>'sqlite')[:a___b].sql.must_equal "SELECT * FROM `a` AS 'b'"
     ensure
-      Sequel.quote_identifiers = qi
-      Sequel::Database.send(:instance_variable_set, :@identifier_input_method, ii)
-      Sequel::Database.send(:instance_variable_set, :@identifier_output_method, io)
+      deprecated do
+        Sequel.quote_identifiers = qi
+        Sequel::Database.send(:instance_variable_set, :@identifier_input_method, ii)
+        Sequel::Database.send(:instance_variable_set, :@identifier_output_method, io)
+      end
     end
   end
 end
 
 describe Sequel::Model, ".[] optimization" do
   before do
-    @db = Sequel.mock(:identifier_mangling=>true, :quote_identifiers=>true)
+    @db = Sequel.mock(:quote_identifiers=>true).extension(:identifier_mangling)
     def @db.schema(*) [[:id, {:primary_key=>true}]] end
     def @db.supports_schema_parsing?() true end
     @c = Class.new(Sequel::Model(@db))