sequel 4.41.0 → 4.42.0

data/spec/extensions/duplicate_columns_handler_spec.rb

@@ -3,24 +3,24 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 mod = shared_description do
   it "should take action depending on :on_duplicate_columns if 2 or more columns have the same name" do
     check(nil, @cols)
-    @warned.must_equal nil
+    @warned.must_be_nil
 
     check(:ignore, @cols)
-    @warned.must_equal nil
+    @warned.must_be_nil
 
     check(:warn, @cols)
-    @warned.must_equal("One or more duplicate columns present in #{@cols.inspect}")
+    @warned.must_include("One or more duplicate columns present in #{@cols.inspect}")
 
     proc{check(:raise, @cols)}.must_raise(Sequel::DuplicateColumnError)
 
     cols = nil
     check(proc{|cs| cols = cs; nil}, @cols)
-    @warned.must_equal nil
+    @warned.must_be_nil
     cols.must_equal @cols
 
     cols = nil
     check(proc{|cs| cols = cs; :ignore}, @cols)
-    @warned.must_equal nil
+    @warned.must_be_nil
     cols.must_equal @cols
 
     cols = nil
@@ -29,17 +29,17 @@ mod = shared_description do
 
     cols = nil
     check(proc{|cs| cols = cs; :warn}, @cols)
-    @warned.must_equal("One or more duplicate columns present in #{@cols.inspect}")
+    @warned.must_include("One or more duplicate columns present in #{@cols.inspect}")
     cols.must_equal @cols
 
     check(:raise, nil)
-    @warned.must_equal nil
+    @warned.must_be_nil
   end
 
   it "should not raise error or warning if no columns have the same name" do
     [nil, :ignore, :raise, :warn, proc{|cs| :raise}].each do |handler|
       check(handler, @cols.uniq)
-      @warned.must_equal nil
+      @warned.must_be_nil
     end
   end
 end
@@ -48,13 +48,10 @@ describe "Sequel::DuplicateColumnsHandler Database configuration" do
   before do
     @db = Sequel.mock
     @db.extension(:duplicate_columns_handler)
-    @ds = @db[:things]
     @cols = [:id, :name, :id]
     @warned = nil
     set_warned = @set_warned = proc{|m| @warned = m}
-    @ds.meta_def(:warn) do |message|
-      set_warned.call(message)
-    end
+    @ds = @db[:things].with_extend{define_method(:warn){|message| set_warned.call(message)}}
   end
 
   def check(handler, cols)
@@ -68,13 +65,10 @@ end
 
 describe "Sequel::DuplicateColumnsHandler Dataset configuration" do
   before do
-    @ds = Sequel.mock[:things].extension!(:duplicate_columns_handler)
     @cols = [:id, :name, :id]
     @warned = nil
     set_warned = @set_warned = proc{|m| @warned = m}
-    @ds.meta_def(:warn) do |message|
-      set_warned.call(message)
-    end
+    @ds = Sequel.mock[:things].extension(:duplicate_columns_handler).with_extend{define_method(:warn){|message| set_warned.call(message)}}
   end
 
   def check(handler, cols)
@@ -98,13 +92,13 @@ describe "Sequel::DuplicateColumnsHandler Dataset configuration" do
 
   it "should warn by defaul if there is no database or dataset handler" do
     @ds.send(:columns=, @cols)
-    @warned.must_equal("One or more duplicate columns present in #{@cols.inspect}")
+    @warned.must_include("One or more duplicate columns present in #{@cols.inspect}")
   end
 
   it "should fallback to database setting if there is no dataset-level handler" do
     @ds.db.opts[:on_duplicate_columns] = :raise
     proc{@ds.send(:columns=, @cols)}.must_raise(Sequel::DuplicateColumnError)
     check(:ignore, @cols)
-    @warned.must_equal nil
+    @warned.must_be_nil
   end
 end

data/spec/extensions/eager_each_spec.rb

@@ -11,9 +11,8 @@ describe "Sequel::Plugins::EagerEach" do
 
   it "should make #each on an eager dataset do eager loading" do
     a = []
-    ds = @c.eager(:children)
-    ds._fetch = [{:id=>1, :parent_id=>nil}, {:id=>2, :parent_id=>nil}]
-    @c.dataset._fetch = [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}, {:id=>5, :parent_id=>2}, {:id=>6, :parent_id=>2}]
+    ds = @c.eager(:children).with_fetch([{:id=>1, :parent_id=>nil}, {:id=>2, :parent_id=>nil}])
+    @c.dataset = @c.dataset.with_fetch([{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}, {:id=>5, :parent_id=>2}, {:id=>6, :parent_id=>2}])
     ds.each{|c| a << c}
     a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
     a.map{|c| c.associations[:children]}.must_equal [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
@@ -25,8 +24,7 @@ describe "Sequel::Plugins::EagerEach" do
 
   it "should make #each on an eager_graph dataset do eager loading" do
     a = []
-    ds = @c.eager_graph(:children)
-    ds._fetch = [{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}, {:id=>2, :parent_id=>nil, :children_id=>5, :children_parent_id=>2}, {:id=>2, :parent_id=>nil, :children_id=>6, :children_parent_id=>2}]
+    ds = @c.eager_graph(:children).with_fetch([{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}, {:id=>2, :parent_id=>nil, :children_id=>5, :children_parent_id=>2}, {:id=>2, :parent_id=>nil, :children_id=>6, :children_parent_id=>2}])
     ds.each{|c| a << c}
     a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
     a.map{|c| c.associations[:children]}.must_equal [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
@@ -34,9 +32,8 @@ describe "Sequel::Plugins::EagerEach" do
   end
 
   it "should make #first on an eager dataset do eager loading" do
-    ds = @c.eager(:children)
-    ds._fetch = [{:id=>1, :parent_id=>nil}]
-    @c.dataset._fetch = [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}]
+    ds = @c.eager(:children).with_fetch([{:id=>1, :parent_id=>nil}])
+    @c.dataset = @c.dataset.with_fetch([{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}])
     a = ds.first
     a.values.must_equal(:id=>1, :parent_id=>nil)
     a.associations[:children].must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)]
@@ -44,9 +41,7 @@ describe "Sequel::Plugins::EagerEach" do
   end
 
   it "should make #first on an eager_graph dataset do eager loading" do
-    ds = @c.eager_graph(:children)
-    ds._fetch = [[{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}], [{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}]]
-    a = ds.first
+    a = @c.eager_graph(:children).with_fetch([[{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}], [{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}]]).first
     a.values.must_equal(:id=>1, :parent_id=>nil)
     a.associations[:children].must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)]
     @c.db.sqls.must_equal ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id) LIMIT 1',
@@ -54,13 +49,14 @@ describe "Sequel::Plugins::EagerEach" do
   end
 
   it "should make #first on a non-eager dataset work correctly" do
-    @c.dataset._fetch = [{:id=>1, :parent_id=>nil}]
-    @c.first.must_equal @c.load(:id=>1, :parent_id=>nil)
+    @c.dataset.with_fetch([{:id=>1, :parent_id=>nil}]).first.must_equal @c.load(:id=>1, :parent_id=>nil)
+  end
+
+  it "should get columns normally columns" do
+    @c.dataset.columns!.must_equal [:id, :parent_id]
   end
 
   it "should not attempt to eager load when getting the columns" do
-    ds = @c.eager(:children)
-    def ds.all; raise; end
-    ds.columns!
+    ds = @c.eager(:children).with_extend{def all; raise; end}.columns!.must_equal [:id, :parent_id]
   end
 end

data/spec/extensions/empty_array_consider_nulls_spec.rb

@@ -13,9 +13,9 @@ describe "filter_having extension" do
   end
 
   it "should handle IN/NOT IN queries with multiple columns and an empty dataset where the database doesn't support it" do
-    @dataset.meta_def(:supports_multiple_column_in?){false}
     db = Sequel.mock
     d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2)
+    @dataset = @dataset.with_extend{def supports_multiple_column_in?; false end}
     @dataset.filter([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE ((id1 != id1) AND (id2 != id2))"
     db.sqls.must_equal ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
     @dataset.exclude([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE ((id1 = id1) AND (id2 = id2))"

data/spec/extensions/eval_inspect_spec.rb

@@ -4,9 +4,10 @@ Sequel.extension :eval_inspect
 
 describe "eval_inspect extension" do
   before do
-    @ds = Sequel.mock.dataset
-    @ds.meta_def(:supports_window_functions?){true}
-    @ds.meta_def(:literal_blob_append){|sql, s| sql << "X'#{s}'"}
+    @ds = Sequel.mock.dataset.with_extend do
+      def supports_window_functions?; true end
+      def literal_blob_append(sql, s) sql << "X'#{s}'" end
+    end
   end
 
   it "should make eval(obj.inspect) == obj for all Sequel::SQL::Expression subclasses" do

data/spec/extensions/force_encoding_spec.rb

@@ -83,13 +83,13 @@ describe "force_encoding plugin" do
   
   it "should work when saving new model instances" do
     o = @c.new
-    ds = DB[:a]
-    def ds.first
-      s = 'blah'.dup
-      s.force_encoding('US-ASCII')
-      {:id=>1, :x=>s}
+    @c.dataset = DB[:a].with_extend do
+      def first
+        s = 'blah'.dup
+        s.force_encoding('US-ASCII')
+        {:id=>1, :x=>s}
+      end
     end
-    @c.dataset = ds
     o.save
     o.x.must_equal 'blah'
     o.x.encoding.must_equal @e1
@@ -97,13 +97,13 @@ describe "force_encoding plugin" do
   
   it "should work when refreshing model instances" do
     o = @c.load(:id=>1, :x=>'as'.dup)
-    ds = DB[:a]
-    def ds.first
-      s = 'blah'.dup
-      s.force_encoding('US-ASCII')
-      {:id=>1, :x=>s}
+    @c.dataset = DB[:a].with_extend do
+      def first
+        s = 'blah'.dup
+        s.force_encoding('US-ASCII')
+        {:id=>1, :x=>s}
+      end
     end
-    @c.dataset = ds
     o.refresh
     o.x.must_equal 'blah'
     o.x.encoding.must_equal @e1

data/spec/extensions/freeze_datasets_spec.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "freeze_datasets extension" do
+  before do
+    @db = Sequel.mock.extension(:freeze_datasets)
+  end
+
+  it "should freeze datasets by default" do
+    @db.dataset.frozen?.must_equal true
+    @db.fetch('SQL').frozen?.must_equal true
+    @db.from(:table).frozen?.must_equal true
+    @db[:table].frozen?.must_equal true
+  end
+
+  it "should have dataset#dup return frozen dataset" do
+    @db.dataset.dup.frozen?.must_equal true
+  end
+
+  it "should cache Database#from calls with single symbol tables" do
+    @db.from(:foo).must_be_same_as @db.from(:foo)
+    @db.from(Sequel[:foo]).wont_be_same_as @db.from(Sequel[:foo])
+  end
+
+  it "should clear Database#from cache when modifying the schema" do
+    ds = @db.from(:foo)
+    ds.columns(:foo, :bar)
+    @db[:foo].columns.must_equal [:foo, :bar]
+    @db.create_table!(:foo){Integer :x}
+    @db[:foo].columns.wont_equal [:foo, :bar]
+  end
+end

data/spec/extensions/graph_each_spec.rb

@@ -20,25 +20,15 @@ describe Sequel::Dataset, " graphing" do
   end
 
   it "#graph_each should handle graph using currently selected columns as the basis for the selected columns in a new graph" do
-    ds = @ds1.select(:id).graph(@ds2, :x=>:id)
-    ds._fetch = {:id=>1, :lines_id=>2, :x=>3, :y=>4, :graph_id=>5}
-    ds.all.must_equal [{:points=>{:id=>1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+    @ds1.select(:id).graph(@ds2, :x=>:id).with_fetch(:id=>1, :lines_id=>2, :x=>3, :y=>4, :graph_id=>5).all.must_equal [{:points=>{:id=>1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
-    ds = @ds1.select(:id, :x).graph(@ds2, :x=>:id)
-    ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
-    ds.all.must_equal [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+    @ds1.select(:id, :x).graph(@ds2, :x=>:id).with_fetch(:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5).all.must_equal [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
-    ds = @ds1.select(Sequel.identifier(:id), Sequel.qualify(:points, :x)).graph(@ds2, :x=>:id)
-    ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
-    ds.all.must_equal [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+    @ds1.select(Sequel.identifier(:id), Sequel.qualify(:points, :x)).graph(@ds2, :x=>:id).with_fetch(:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5).all.must_equal [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
-    ds = @ds1.select(Sequel.identifier(:id).qualify(:points), Sequel.identifier(:x).as(:y)).graph(@ds2, :x=>:id)
-    ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
-    ds.all.must_equal [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+    @ds1.select(Sequel.identifier(:id).qualify(:points), Sequel.identifier(:x).as(:y)).graph(@ds2, :x=>:id).with_fetch(:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5).all.must_equal [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
-    ds = @ds1.select(:id, Sequel.identifier(:x).qualify(Sequel.identifier(:points)).as(Sequel.identifier(:y))).graph(@ds2, :x=>:id)
-    ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
-    ds.all.must_equal [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+    @ds1.select(:id, Sequel.identifier(:x).qualify(Sequel.identifier(:points)).as(Sequel.identifier(:y))).graph(@ds2, :x=>:id).with_fetch(:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5).all.must_equal [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
   end
 
   it "#graph_each should split the result set into component tables" do
@@ -111,10 +101,8 @@ describe Sequel::Dataset, " graphing" do
   end
 
   it "#graph_each should run the row_proc for graphed datasets" do
-    @ds1.row_proc = proc{|h| h.keys.each{|k| h[k] *= 2}; h}
-    @ds2.row_proc = proc{|h| h.keys.each{|k| h[k] *= 3}; h}
     @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}
-    @ds1.graph(@ds2, :x=>:id).all.must_equal [{:points=>{:id=>2, :x=>4, :y=>6}, :lines=>{:id=>12, :x=>15, :y=>18, :graph_id=>21}}]
+    @ds1.with_row_proc(proc{|h| h.keys.each{|k| h[k] *= 2}; h}).graph(@ds2.with_row_proc(proc{|h| h.keys.each{|k| h[k] *= 3}; h}), :x=>:id).all.must_equal [{:points=>{:id=>2, :x=>4, :y=>6}, :lines=>{:id=>12, :x=>15, :y=>18, :graph_id=>21}}]
   end
 
   it "#with_sql_each should work normally if the dataset is not graphed" do

data/spec/extensions/hook_class_methods_spec.rb

@@ -197,14 +197,14 @@ describe "Model#before_create && Model#after_create" do
   it ".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_equal nil
+    @c.create(:x => 2).must_be_nil
     DB.sqls.must_equal []
   end
 
   it ".create should cancel the save and return nil if before_create calls cancel_action and raise_on_save_failure is false" do
     @c.before_create{cancel_action}
     @c.raise_on_save_failure = false
-    @c.create(:x => 2).must_equal nil
+    @c.create(:x => 2).must_be_nil
     DB.sqls.must_equal []
   end
 end
@@ -234,7 +234,7 @@ describe "Model#before_update && Model#after_update" do
   it "#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_equal nil
+    @c.load(:id => 2233).save.must_be_nil
     DB.sqls.must_equal []
   end
 end
@@ -272,7 +272,7 @@ describe "Model#before_save && Model#after_save" do
   it "#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_equal nil
+    @c.load(:id => 2233).save.must_be_nil
     DB.sqls.must_equal []
   end
 end
@@ -302,7 +302,7 @@ describe "Model#before_destroy && Model#after_destroy" do
   it "#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_equal nil
+    @c.load(:id => 2233).destroy.must_be_nil
     DB.sqls.must_equal []
   end
 end
@@ -343,7 +343,7 @@ describe "Model#before_validation && Model#after_validation" do
     DB.sqls.clear
     m = @c.load(:id => 22)
     m.raise_on_save_failure = false
-    m.save.must_equal nil
+    m.save.must_be_nil
     DB.sqls.must_equal ['BLAH before', 'BLAH after']
   end
 
@@ -356,7 +356,7 @@ describe "Model#before_validation && Model#after_validation" do
   it "#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_equal nil
+    @c.load(:id => 2233).save.must_be_nil
     DB.sqls.must_equal []
   end
 end

data/spec/extensions/identifier_mangling_spec.rb

@@ -0,0 +1,307 @@
+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
+  end
+  
+  it "should respect the :quote_identifiers option" do
+    db = Sequel::Database.new(:quote_identifiers=>false, :identifier_mangling=>true)
+    db.quote_identifiers?.must_equal false
+    db = Sequel::Database.new(:quote_identifiers=>true, :identifier_mangling=>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.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.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.identifier_input_method.must_equal :upcase
+    db.identifier_input_method = nil
+    db.identifier_input_method.must_be_nil
+    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.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.identifier_input_method.must_equal :upcase
+    db.identifier_input_method = nil
+    db.identifier_input_method.must_be_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, :identifier_mangling=>true)
+    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.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
+    db.identifier_output_method.must_equal :upcase
+    db = Sequel::Database.new(:identifier_output_method=>:upcase, :identifier_mangling=>true)
+    db.identifier_output_method.must_equal :upcase
+    db.identifier_output_method = nil
+    db.identifier_output_method.must_be_nil
+  end
+
+  it "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.quote_identifiers = false
+    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal false
+    Sequel::Database.quote_identifiers = true
+    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
+    Sequel::Database.quote_identifiers = false
+    Sequel::Database.new(:identifier_mangling=>true).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_mangling=>true).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.identifier_input_method = :downcase
+    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :downcase
+    Sequel::Database.identifier_input_method = :upcase
+    Sequel::Database.new(:identifier_mangling=>true).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_mangling=>true).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.identifier_output_method = :downcase
+    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :downcase
+    Sequel::Database.identifier_output_method = :upcase
+    Sequel::Database.new(:identifier_mangling=>true).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(:identifier_mangling=>true).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
+    y = Class.new(Sequel::Database){def quote_identifiers_default; true end}
+    y.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
+  end
+  
+  it "should respect the identifier_input_method_default method if Sequel.identifier_input_method is not called" do
+    class Sequel::Database
+      @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
+    y = Class.new(Sequel::Database){def identifier_input_method_default; :camelize end}
+    y.new(:identifier_mangling=>true).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_mangling=>true).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
+  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.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(:identifier_mangling=>true)
+    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_mangling" do
+    ds = Sequel::Database.new(:identifier_mangling=>true).send(:metadata_dataset)
+    ds.literal(:a).must_equal 'A'
+    ds.send(:output_identifier, 'A').must_equal :a
+  end
+end
+
+describe "Dataset" do
+  before do
+    @dataset = Sequel.mock(:identifier_mangling=>true).dataset
+  end
+  
+  it "should get quote_identifiers default from database" do
+    db = Sequel::Database.new(:quote_identifiers=>true, :identifier_mangling=>true)
+    db[:a].quote_identifiers?.must_equal true
+    db = Sequel::Database.new(:quote_identifiers=>false, :identifier_mangling=>true)
+    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[:a].identifier_input_method.must_equal :upcase
+    db = Sequel::Database.new(:identifier_input_method=>:downcase, :identifier_mangling=>true)
+    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[:a].identifier_output_method.must_equal :upcase
+    db = Sequel::Database.new(:identifier_output_method=>:downcase, :identifier_mangling=>true)
+    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
+      @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
+      @dataset.identifier_input_method = :upcase
+      @dataset.literal(:a).must_equal 'A'
+      @dataset.identifier_input_method = :downcase
+      @dataset.literal(:A).must_equal 'a'
+      @dataset.identifier_input_method = :reverse
+      @dataset.literal(:at_b).must_equal 'b_ta'
+    end
+    
+    it "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
+      @dataset.identifier_output_method = :downcase
+      @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_c
+      @dataset.identifier_output_method = :reverse
+      @dataset.send(:output_identifier, "at_b_C").must_equal :C_b_ta
+    end
+  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.with_identifier_output_method(:upcase).send(:output_identifier, "").must_equal :UNTITLED
+    @dataset.with_identifier_output_method(:downcase).send(:output_identifier, "").must_equal :untitled
+    @dataset.with_identifier_output_method(:reverse).send(:output_identifier, "").must_equal :deltitnu
+  end
+end
+
+describe "Frozen Datasets" do
+  before do
+    @ds = Sequel.mock(:identifier_mangling=>true)[:test].freeze
+  end
+
+  it "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
+  end
+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
+      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)'
+      Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM \"a\" WHERE (to_tsvector(CAST('simple' AS regconfig), (COALESCE(\"b\", ''))) @@ to_tsquery(CAST('simple' AS regconfig), 'c'))"
+      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)
+    end
+  end
+end
+
+describe Sequel::Model, ".[] optimization" do
+  before do
+    @db = Sequel.mock(:identifier_mangling=>true, :quote_identifiers=>true)
+    def @db.schema(*) [[:id, {:primary_key=>true}]] end
+    def @db.supports_schema_parsing?() true end
+    @c = Class.new(Sequel::Model(@db))
+    @ds = @db.dataset.with_quote_identifiers(true)
+  end
+
+  it "should have simple_pk and simple_table respect dataset's identifier input methods" do
+    ds = @db.from(:ab).with_identifier_input_method(:reverse)
+    @c.set_dataset ds
+    @c.simple_table.must_equal '"ba"'
+    @c.set_primary_key :cd
+    @c.simple_pk.must_equal '"dc"'
+
+    @c.set_dataset ds.from(:ef__gh)
+    @c.simple_table.must_equal '"fe"."hg"'
+  end
+end