sequel 4.47.0 → 4.48.0

data/spec/core/spec_helper.rb

@@ -19,6 +19,7 @@ require 'minitest/shared_description'
 require "#{File.dirname(File.dirname(__FILE__))}/deprecation_helper.rb"
 
 class Minitest::HooksSpec
+  # SEQUEL5: Replace with define_singleton_method
   def meta_def(obj, name, &block)
     (class << obj; self end).send(:define_method, name, &block)
   end

data/spec/core_extensions_spec.rb

@@ -316,13 +316,17 @@ describe "Array#sql_value_list and #sql_array" do
   it "should treat the array as an SQL value list instead of conditions when used as a placeholder value" do
     @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]])).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x = 1) AND (y = 2)))'
     @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_value_list)).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
-    @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_array)).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    deprecated do
+      @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_array)).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    end
   end
 
   it "should be no difference when used as a hash value" do
     @d.filter([:a, :b]=>[[:x, 1], [:y, 2]]).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
     @d.filter([:a, :b]=>[[:x, 1], [:y, 2]].sql_value_list).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
-    @d.filter([:a, :b]=>[[:x, 1], [:y, 2]].sql_array).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    deprecated do
+      @d.filter([:a, :b]=>[[:x, 1], [:y, 2]].sql_array).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    end
   end
 end
 

data/spec/extensions/active_model_spec.rb

@@ -59,7 +59,7 @@ describe "ActiveModel plugin" do
     @c.freeze
     @o.id2 = 2
     @o.to_param.must_equal '2-1'
-    @o.meta_def(:to_param_joiner){'|'}
+    def @o.to_param_joiner; '|' end
     @o.to_param.must_equal '2|1'
     @o.destroy
     @o.to_param.must_be_nil

data/spec/extensions/arbitrary_servers_spec.rb

@@ -33,7 +33,7 @@ describe "arbtirary servers" do
 
   it "should disconnect when connection is finished" do
     x, x1 = nil, nil
-    @db.meta_def(:disconnect_connection){|c| x = c}
+    meta_def(@db, :disconnect_connection){|c| x = c}
     @db.synchronize(:host=>'host1', :database=>'db1') do |c|
       x1 = c
       @db.synchronize(:host=>'host1', :database=>'db1') do |c2|

data/spec/extensions/association_pks_spec.rb

@@ -8,7 +8,8 @@ describe "Sequel::Plugins::AssociationPks" do
         {:id=>$1.to_i}
       when "SELECT id FROM albums WHERE (albums.artist_id = 1)"
         [{:id=>1}, {:id=>2}, {:id=>3}]
-      when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/
+      when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/,
+           /SELECT tags.id FROM tags INNER JOIN albums_tags ON \(albums_tags.tag_id = tags.id\) WHERE \(albums_tags.album_id = (\d)\)/
         a = []
         a << {:tag_id=>1} if $1 == '1'
         a << {:tag_id=>2} if $1 != '3'
@@ -32,7 +33,8 @@ describe "Sequel::Plugins::AssociationPks" do
         a
       when "SELECT year, week FROM hits WHERE ((hits.first = 'F1') AND (hits.last = 'L1'))"
         [{:year=>1997, :week=>1}, {:year=>1997, :week=>2}]
-      when /SELECT year, week FROM vocalists_hits WHERE \(\((?:first|last) = '?[FL1](\d)/
+      when /SELECT year, week FROM vocalists_hits WHERE \(\((?:first|last) = '?[FL1](\d)/,
+           /SELECT hits.year, hits.week FROM hits INNER JOIN vocalists_hits ON \(\(vocalists_hits.(?:year|week) = hits.(?:year|week)\) AND \(vocalists_hits.(?:year|week) = hits.(?:year|week)\)\) WHERE \(\(vocalists_hits.(?:first|last) = '?[FL1](\d)/
         a = []
         a << {:year=>1997, :week=>1} if $1 == "1"
         a << {:year=>1997, :week=>2} if $1 != "3"
@@ -64,13 +66,28 @@ describe "Sequel::Plugins::AssociationPks" do
 
   it "should return correct associated pks for one_to_many associations" do
     @Artist.load(:id=>1).album_pks.must_equal [1,2,3]
+    @db.sqls.must_equal ["SELECT id FROM albums WHERE (albums.artist_id = 1)"]
     @Artist.load(:id=>2).album_pks.must_equal []
+    @db.sqls.must_equal ["SELECT id FROM albums WHERE (albums.artist_id = 2)"]
   end
 
   it "should return correct associated pks for many_to_many associations" do
     @Album.load(:id=>1).tag_pks.must_equal [1, 2]
+    @db.sqls.must_equal ["SELECT tag_id FROM albums_tags WHERE (album_id = 1)"]
     @Album.load(:id=>2).tag_pks.must_equal [2, 3]
+    @db.sqls.must_equal ["SELECT tag_id FROM albums_tags WHERE (album_id = 2)"]
     @Album.load(:id=>3).tag_pks.must_equal []
+    @db.sqls.must_equal ["SELECT tag_id FROM albums_tags WHERE (album_id = 3)"]
+  end
+
+  it "should return correct associated pks for many_to_many associations using :association_pks_use_associated_table" do
+    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id, :delay_pks=>false, :association_pks_use_associated_table=>true
+    @Album.load(:id=>1).tag_pks.must_equal [1, 2]
+    @db.sqls.must_equal ["SELECT tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1)"]
+    @Album.load(:id=>2).tag_pks.must_equal [2, 3]
+    @db.sqls.must_equal ["SELECT tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 2)"]
+    @Album.load(:id=>3).tag_pks.must_equal []
+    @db.sqls.must_equal ["SELECT tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 3)"]
   end
 
   deprecated "should set associated pks correctly for a one_to_many association when :delay_pks is not set" do
@@ -171,14 +188,29 @@ describe "Sequel::Plugins::AssociationPks" do
   it "should return correct right-side associated cpks for left-side cpks for one_to_many associations" do
     @Vocalist.one_to_many :hits, :class=>@Hit, :key=>[:first, :last]
     @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.must_equal [[1997, 1], [1997, 2]]
+    @db.sqls.must_equal ["SELECT year, week FROM hits WHERE ((hits.first = 'F1') AND (hits.last = 'L1'))"]
     @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.must_equal []
+    @db.sqls.must_equal ["SELECT year, week FROM hits WHERE ((hits.first = 'F2') AND (hits.last = 'L2'))"]
   end
 
   it "should return correct right-side associated cpks for left-side cpks for many_to_many associations" do
     @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week]
     @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.must_equal [[1997, 1], [1997, 2]]
+    @db.sqls.must_equal ["SELECT year, week FROM vocalists_hits WHERE ((first = 'F1') AND (last = 'L1'))"]
+    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.must_equal [[1997, 2], [1997, 3]]
+    @db.sqls.must_equal ["SELECT year, week FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2'))"]
+    @Vocalist.load(:first=>'F3', :last=>'L3').hit_pks.must_equal []
+    @db.sqls.must_equal ["SELECT year, week FROM vocalists_hits WHERE ((first = 'F3') AND (last = 'L3'))"]
+  end
+
+  it "should return correct right-side associated cpks for left-side cpks for many_to_many associations when using :association_pks_use_associated_table" do
+    @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week], :association_pks_use_associated_table=>true
+    @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.must_equal [[1997, 1], [1997, 2]]
+    @db.sqls.must_equal ["SELECT hits.year, hits.week FROM hits INNER JOIN vocalists_hits ON ((vocalists_hits.year = hits.year) AND (vocalists_hits.week = hits.week)) WHERE ((vocalists_hits.first = 'F1') AND (vocalists_hits.last = 'L1'))"]
     @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.must_equal [[1997, 2], [1997, 3]]
+    @db.sqls.must_equal ["SELECT hits.year, hits.week FROM hits INNER JOIN vocalists_hits ON ((vocalists_hits.year = hits.year) AND (vocalists_hits.week = hits.week)) WHERE ((vocalists_hits.first = 'F2') AND (vocalists_hits.last = 'L2'))"]
     @Vocalist.load(:first=>'F3', :last=>'L3').hit_pks.must_equal []
+    @db.sqls.must_equal ["SELECT hits.year, hits.week FROM hits INNER JOIN vocalists_hits ON ((vocalists_hits.year = hits.year) AND (vocalists_hits.week = hits.week)) WHERE ((vocalists_hits.first = 'F3') AND (vocalists_hits.last = 'L3'))"]
   end
 
   it "should set associated right-side cpks correctly for left-side cpks for a one_to_many association" do

data/spec/extensions/auto_literal_strings_spec.rb

@@ -9,6 +9,10 @@ describe "Dataset#where" do
     @dataset.where('price < ? AND id in ?', 100, [1, 2, 3]).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
   end
   
+  it "should use default behavior for array of conditions" do
+    @dataset.where([[:a, 1], [:b, 2]]).sql.must_equal 'SELECT * FROM test WHERE ((a = 1) AND (b = 2))'
+  end
+
   it "should not modify passed array with placeholders" do
     a = ['price < ? AND id in ?', 100, 1, 2, 3]
     b = a.dup
@@ -114,7 +118,7 @@ describe "Dataset#and" do
     @d1 = @dataset.where(:x => 1)
   end
 
-  it "should accept string filters with placeholders" do
+  deprecated "should accept string filters with placeholders" do
     @d1.and('y > ?', 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
   end
 end

data/spec/extensions/auto_validations_spec.rb

@@ -98,6 +98,8 @@ describe "Sequel::Plugins::AutoValidations" do
     @m = @c.new
     @c.skip_auto_validations(:not_null)
     @m.valid?.must_equal true
+    @m.nnd = nil
+    @m.valid?.must_equal true
 
     @m.set(:d=>'/', :num=>'a', :name=>'1')
     @m.valid?.must_equal false

data/spec/extensions/boolean_readers_spec.rb

@@ -86,7 +86,7 @@ describe Sequel::Model, "BooleanReaders plugin" do
   end
 
   it "should handle cases where getting the columns raises an error" do
-    @c.meta_def(:columns){raise Sequel::Error}
+    def @c.columns; raise Sequel::Error end
     @c.plugin(:boolean_readers)
     proc{@c.new.b?}.must_raise(NoMethodError)
   end

data/spec/extensions/boolean_subsets_spec.rb

@@ -40,7 +40,7 @@ describe "boolean_subsets plugin" do
   end
 
   it "should handle cases where getting the columns raises an error" do
-    @c.meta_def(:columns){raise Sequel::Error}
+    def @c.columns; raise Sequel::Error end
     @c.plugin(:boolean_subsets)
     @c.respond_to?(:active).must_equal false
   end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -62,6 +62,11 @@ describe "class_table_inheritance plugin" do
     Employee.cti_table_map.frozen?.must_equal true
   end
 
+  deprecated "should support cti_key and cti_model_map" do
+    Employee.cti_key.must_equal Employee.sti_key
+    Employee.cti_model_map.must_equal Employee.sti_model_map
+  end
+
   deprecated "should not attempt to use prepared statements" do
     Manager.plugin :prepared_statements
     Manager[1]
@@ -572,10 +577,14 @@ describe "class_table_inheritance plugin with :alias option" do
     @db.sqls.must_equal ["SELECT * FROM (SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)) AS employees WHERE (id = 1) LIMIT 1"]
   end
 
-  it "#cti_base_model should be the model that loaded the plugin" do
+  deprecated "#cti_base_model should be the model that loaded the plugin" do
     Executive.cti_base_model.must_equal Employee
   end
 
+  it "#cti_models.first should be the model that loaded the plugin" do
+    Executive.cti_models.first.must_equal Employee
+  end
+
   it "#cti_columns should be a mapping of table names to columns" do
     Executive.cti_columns.must_equal(:employees=>[:id, :name, :kind], :managers=>[:id, :num_staff], :executives=>[:id, :num_managers])
   end
@@ -668,6 +677,39 @@ describe "class_table_inheritance plugin with :alias option" do
       "INSERT INTO executives (id) VALUES (1)"]
   end
 
+  it "should sets the model class name for the key when creating new subclass records" do
+    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive, 3=>:Ceo}, :alias=>:employees)
+    Object.send(:remove_const, :Ceo)
+    Object.send(:remove_const, :Executive)
+    Object.send(:remove_const, :Manager)
+    class ::Manager < Employee; end 
+    class ::Executive < Manager; end 
+    class ::Ceo < Executive; end 
+    Ceo.create
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('3')",
+      "INSERT INTO managers (id) VALUES (1)",
+      "INSERT INTO executives (id) VALUES (1)"]
+  end
+
+  it "should sets the model class name for the key when creating new subclass records" do
+    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive, 3=>:Ceo}, :alias=>:employees)
+    Object.send(:remove_const, :Ceo)
+    Object.send(:remove_const, :Executive)
+    Object.send(:remove_const, :Manager)
+    class ::Manager < Employee; end 
+    class ::Executive < Employee; end 
+    class ::Ceo < Employee; end 
+    Ceo.create
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('3')"]
+  end
+
+  it "should not use a subquery for a class that doesn't join to a separate table" do
+    Employee.plugin(:class_table_inheritance, :key=>:kind, :model_map=>{0=>:Employee, 1=>:Manager, 2=>:Executive, 3=>:Ceo}, :alias=>:employees)
+    Object.send(:remove_const, :Ceo)
+    class ::Ceo < Employee; end 
+    Ceo.dataset.sql.must_equal 'SELECT * FROM employees WHERE (employees.kind IN (3))'
+  end
+
   it "should ignore existing cti_key value when creating new records" do
     Employee.create(:kind=>'Manager')
     @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Employee')"]
@@ -1069,10 +1111,14 @@ describe "class_table_inheritance plugin with :alias option" do
     @db.sqls.must_equal ["SELECT * FROM (SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)) AS employees WHERE (id = 1) LIMIT 1"]
   end
 
-  it "#cti_base_model should be the model that loaded the plugin" do
+  deprecated "#cti_base_model should be the model that loaded the plugin" do
     Executive.cti_base_model.must_equal Employee
   end
 
+  it "#cti_models.first should be the model that loaded the plugin" do
+    Executive.cti_models.first.must_equal Employee
+  end
+
   it "#cti_columns should be a mapping of table names to columns" do
     Executive.cti_columns.must_equal(:employees=>[:id, :name, :kind], :managers=>[:id, :num_staff], :executives=>[:id, :num_managers])
   end

data/spec/extensions/column_conflicts_spec.rb

@@ -39,6 +39,17 @@ describe "column_conflicts plugin" do
     @o.get_column_value(:model).must_equal 2
   end
 
+  it "should not erase existing column conflicts when loading the plugin" do
+    @c.send(:define_method, :foo){raise}
+    @c.send(:define_method, :model=){raise}
+    @c.get_column_conflict!(:foo)
+    @c.set_column_conflict!(:model)
+    @c.plugin :column_conflicts
+    @o.get_column_value(:foo).must_equal 4
+    @o.set_column_value(:model=, 2).must_equal 2
+    @o.get_column_value(:model).must_equal 2
+  end
+
   it "should work correctly in subclasses" do
     @o = Class.new(@c).load(:model=>1, :use_transactions=>2)
     @o.get_column_value(:model).must_equal 1

data/spec/extensions/connection_validator_spec.rb

@@ -104,7 +104,7 @@ connection_validator_specs = shared_description do
     end
 
     it "should handle case where determining validity requires a connection" do
-      @db.meta_def(:valid_connection?){|c| synchronize{}; true}
+      def @db.valid_connection?(c) synchronize{}; true end
       @db.pool.connection_validation_timeout = -1
       c1 = @db.synchronize{|c| c}
       @db.synchronize{|c| c}.must_be_same_as(c1)

data/spec/extensions/dataset_associations_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::DatasetAssociations" do
   before do
-    @db = Sequel.mock
+    @db = Sequel.mock(:host=>'postgres')
     @db.extend_datasets do
       def supports_window_functions?; true; end
       def supports_distinct_on?; true; end
@@ -14,9 +14,9 @@ describe "Sequel::Plugins::DatasetAssociations" do
     @Album = Class.new(@Base)
     @Tag = Class.new(@Base)
 
-    @Artist.meta_def(:name){'Artist'}
-    @Album.meta_def(:name){'Album'}
-    @Tag.meta_def(:name){'Tag'}
+    def @Artist.name; 'Artist' end
+    def @Album.name; 'Album' end
+    def @Tag.name; 'Tag' end
 
     @Artist.dataset = @db[:artists]
     @Album.dataset = @db[:albums]
@@ -142,7 +142,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
     ds = @Tag.artists
     ds.must_be_kind_of(Sequel::Dataset)
     ds.model.must_equal @Artist
-    ds.sql.must_equal "SELECT * FROM artists WHERE coalesce((tag_ids && (SELECT array_agg(tags.id) FROM tags)), 'f')"
+    ds.sql.must_equal "SELECT * FROM artists WHERE coalesce((tag_ids && (SELECT array_agg(tags.id) FROM tags)), false)"
   end
 
   it "should have an associated method that takes an association symbol" do
@@ -261,9 +261,9 @@ describe "Sequel::Plugins::DatasetAssociations with composite keys" do
     @Album = Class.new(@Base)
     @Tag = Class.new(@Base)
 
-    @Artist.meta_def(:name){'Artist'}
-    @Album.meta_def(:name){'Album'}
-    @Tag.meta_def(:name){'Tag'}
+    def @Artist.name; 'Artist' end
+    def @Album.name; 'Album' end
+    def @Tag.name; 'Tag' end
 
     @Artist.dataset = @db[:artists]
     @Album.dataset = @db[:albums]

data/spec/extensions/defaults_setter_spec.rb

@@ -9,7 +9,7 @@ describe "Sequel::Plugins::DefaultsSetter" do
     @c.instance_variable_set(:@db_schema, {:a=>{}})
     @c.plugin :defaults_setter
     @c.columns :a
-    @pr = proc{|x| db.meta_def(:schema){|*| [[:id, {:primary_key=>true}], [:a, {:ruby_default => x, :primary_key=>false}]]}; c.dataset = c.dataset; c}
+    @pr = proc{|x| meta_def(db, :schema){|*| [[:id, {:primary_key=>true}], [:a, {:ruby_default => x, :primary_key=>false}]]}; c.dataset = c.dataset; c}
   end
   after do
     Sequel.datetime_class = Time

data/spec/extensions/filter_having_spec.rb

@@ -2,7 +2,9 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "filter_having extension" do
   before do
-    @ds = Sequel.mock[:t].extension(:filter_having)
+    deprecated do
+      @ds = Sequel.mock[:t].extension(:filter_having)
+    end
     @dsh = @ds.having(:a)
   end
 
@@ -14,11 +16,11 @@ describe "filter_having extension" do
     @ds.filter(:b).sql.must_equal 'SELECT * FROM t WHERE b'
   end
 
-  it "should make and operate on HAVING clause if dataset has a HAVING clause" do
+  deprecated "should make and operate on HAVING clause if dataset has a HAVING clause" do
     @dsh.and(:b).sql.must_equal 'SELECT * FROM t HAVING (a AND b)'
   end
 
-  it "should make and operate on WHERE clause if dataset does not have a HAVING clause" do
+  deprecated "should make and operate on WHERE clause if dataset does not have a HAVING clause" do
     @ds.where(:a).and(:b).sql.must_equal 'SELECT * FROM t WHERE (a AND b)'
   end
 

data/spec/extensions/hash_aliases_spec.rb

@@ -2,7 +2,9 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "hash_aliases extension" do
   before do
-    @ds = Sequel.mock.dataset.extension(:hash_aliases)
+    deprecated do
+      @ds = Sequel.mock.dataset.extension(:hash_aliases)
+    end
   end
 
   it "should make from treat hash arguments as alias specifiers" do

data/spec/extensions/identifier_columns_spec.rb

@@ -6,7 +6,9 @@ describe "identifier_columns plugin" do
     @c = Class.new(Sequel::Model(@db[:test]))
     @ds = @c.dataset
     @c.columns :id, :a__b
-    @c.plugin :identifier_columns
+    deprecated do
+      @c.plugin :identifier_columns
+    end
     @db.sqls
   end
 

data/spec/extensions/implicit_subquery_spec.rb

@@ -9,13 +9,15 @@ describe "Sequel::Dataset::ImplicitSubquery" do
     ods = db[:c]
     ods.columns(:id, :b)
 
-    ds.and(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
+    deprecated do
+      ds.and(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
+      ds.exclude_where(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE NOT c"
+    end
     ds.cross_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 CROSS JOIN c"
     ds.distinct.sql.must_equal "SELECT DISTINCT * FROM (SELECT * FROM table) AS t1"
     ds.except(ods).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table) AS t1 EXCEPT SELECT * FROM c) AS t1"
     ds.exclude(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE NOT c"
     ds.exclude_having(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 HAVING NOT c"
-    ds.exclude_where(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE NOT c"
     ds.filter(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
     ds.for_update.sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FOR UPDATE"
     ds.full_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FULL JOIN c"

data/spec/extensions/json_serializer_spec.rb

@@ -65,6 +65,12 @@ describe "Sequel::Plugins::JsonSerializer" do
     Album.from_json(@album.to_json(:include=>:artist), :associations=>:artist).artist.must_equal @artist
   end
 
+  it "should have #to_json support blocks for transformations" do
+    values = {}
+    @artist.values.each{|k,v| values[k.to_s] = v}
+    Sequel.parse_json(@artist.to_json{|h| {'data'=>h}}).must_equal({'data'=>values})
+  end
+
   it "should raise an error if attempting to parse json when providing array to non-array association or vice-versa" do
     proc{Artist.from_json('{"albums":{"id":1,"name":"RF","artist_id":2},"id":2,"name":"YJM"}', :associations=>:albums)}.must_raise(Sequel::Error)
     proc{Album.from_json('{"artist":[{"id":2,"name":"YJM"}],"id":1,"name":"RF","artist_id":2}', :associations=>:artist)}.must_raise(Sequel::Error)
@@ -186,6 +192,18 @@ describe "Sequel::Plugins::JsonSerializer" do
     Sequel.parse_json(ds.to_json).must_equal [@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}]
   end
 
+  it "should have class and dataset to_json method accept blocks for transformations" do
+    Album.dataset = Album.dataset.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
+    Sequel.parse_json(Album.to_json{|h| {'data'=>h}}).must_equal('data'=>[@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}])
+    Sequel.parse_json(Album.dataset.to_json{|h| {'data'=>h}}).must_equal('data'=>[@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}])
+  end
+
+  it "should have class and dataset to_json method support :instance_block option for instance_transformations" do
+    Album.dataset = Album.dataset.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
+    Sequel.parse_json(Album.to_json(:instance_block=>lambda{|h| {'data'=>h}})).must_equal [{'data'=>@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}}]
+    Sequel.parse_json(Album.dataset.to_json(:instance_block=>lambda{|h| {'data'=>h}})).must_equal [{'data'=>@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}}]
+  end
+
   it "should have dataset to_json method respect :array option for the array to use" do
     a = Album.new(:name=>'RF', :artist_id=>3)
     Album.array_from_json(Album.to_json(:array=>[a])).must_equal [a]

data/spec/extensions/lazy_attributes_spec.rb

@@ -5,13 +5,13 @@ describe "Sequel::Plugins::LazyAttributes" do
   before do
     @db = Sequel.mock
     def @db.supports_schema_parsing?() true end
-    @db.meta_def(:schema){|*a| [[:id, {:type=>:integer}], [:name,{:type=>:string}]]}
+    def @db.schema(*a) [[:id, {:type=>:integer}], [:name,{:type=>:string}]] end
     class ::LazyAttributesModel < Sequel::Model(@db[:la])
       plugin :lazy_attributes
       set_columns([:id, :name])
-      meta_def(:columns){[:id, :name]}
+      def self.columns; [:id, :name] end
       lazy_attributes :name
-      meta_def(:columns){[:id]}
+      def self.columns; [:id] end
       set_dataset dataset.with_fetch(proc do |sql|
         if sql !~ /WHERE/
           if sql =~ /name/