sequel 4.49.0 → 5.3.0

data/lib/sequel/plugins/instance_hooks.rb

@@ -28,31 +28,16 @@ module Sequel
     #   # Add the instance hook methods just to Album instances
     #   Album.plugin :instance_hooks
     module InstanceHooks
-      BEFORE_HOOKS, AFTER_HOOKS = Sequel::Model::HOOKS.partition{|l| l.to_s.start_with?('before')}
-      Sequel::Deprecation.deprecate_constant(self, :BEFORE_HOOKS)
-      Sequel::Deprecation.deprecate_constant(self, :AFTER_HOOKS)
-      HOOKS = Sequel::Model::HOOKS
-      Sequel::Deprecation.deprecate_constant(self, :HOOKS)
-      
-      # SEQUEL5: Remove
-      DEPRECATION_REPLACEMENTS = {
-        :after_commit=>"Use obj.after_save_hook{obj.db.after_commit{}} instead",
-        :after_destroy_commit=>"Use obj.after_destroy_hook{obj.db.after_commit{}} instead",
-        :after_destroy_rollback=>"Use obj.before_destroy_hook{obj.db.after_rollback{}} instead",
-        :after_rollback=>"Use obj.before_save_hook{obj.db.after_rollback{}} instead"
-      }.freeze
-
       module InstanceMethods 
         Sequel::Model::HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
           def #{h}_hook(&block)
-            #{"Sequel::Deprecation.deprecate('Sequel::Model##{h}_hook in the instance_hooks plugin', #{DEPRECATION_REPLACEMENTS[h].inspect})" if DEPRECATION_REPLACEMENTS[h]}
             raise Sequel::Error, "can't add hooks to frozen object" if frozen?
             add_instance_hook(:#{h}, &block)
             self
           end
         END
         
-        [:before_create, :before_update, :before_validation].each{|h| class_eval("def #{h}; (@instance_hooks && run_before_instance_hooks(:#{h}) == false) ? false : super end", __FILE__, __LINE__)}
+        [:before_create, :before_update, :before_validation].each{|h| class_eval("def #{h}; run_before_instance_hooks(:#{h}) if @instance_hooks; super end", __FILE__, __LINE__)}
         [:after_create, :after_update].each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
           def #{h}
             super
@@ -67,15 +52,9 @@ module Sequel
         def after_destroy
           super
           return unless @instance_hooks
-          # SEQUEL5: Remove commit/rollback
-          if ad = @instance_hooks[:after_destroy_commit]
-            db.after_commit{ad.each(&:call)}
-          end
           run_after_instance_hooks(:after_destroy)
           @instance_hooks.delete(:after_destroy)
           @instance_hooks.delete(:before_destroy)
-          @instance_hooks.delete(:after_destroy_commit)
-          @instance_hooks.delete(:after_destroy_rollback)
         end
 
         # Run after validation instance hooks.
@@ -89,39 +68,25 @@ module Sequel
         def after_save
           super
           return unless @instance_hooks
-          # SEQUEL5: Remove commit/rollback
-          if (ac = @instance_hooks[:after_commit])
-            db.after_commit{ac.each(&:call)}
-          end
           run_after_instance_hooks(:after_save)
           @instance_hooks.delete(:after_save)
           @instance_hooks.delete(:before_save)
           @instance_hooks.delete(:after_validation)
           @instance_hooks.delete(:before_validation)
-          @instance_hooks.delete(:after_commit)
-          @instance_hooks.delete(:after_rollback)
         end
 
         # Run before_destroy instance hooks.
         def before_destroy
           return super unless @instance_hooks
-          # SEQUEL5: Remove commit/rollback
-          if adr = @instance_hooks[:after_destroy_rollback]
-            db.after_rollback{adr.each(&:call)}
-          end
-          # SEQUEL5: No false checking
-          run_before_instance_hooks(:before_destroy) == false ? false : super
+          run_before_instance_hooks(:before_destroy)
+          super
         end
 
         # Run before_save instance hooks.
         def before_save
           return super unless @instance_hooks
-          # SEQUEL5: Remove commit/rollback
-          if ar = @instance_hooks[:after_rollback]
-            db.after_rollback{ar.each(&:call)}
-          end
-          # SEQUEL5: No false checking
-          run_before_instance_hooks(:before_save) == false ? false : super
+          run_before_instance_hooks(:before_save)
+          super
         end
         
         private
@@ -130,7 +95,7 @@ module Sequel
         # the beginning of the instance hook's array.  For after hooks, add it
         # to the end.
         def add_instance_hook(hook, &block)
-          instance_hooks(hook).send(hook.to_s.start_with?('before') ? :unshift : :push, block)
+          instance_hooks(hook).public_send(hook.to_s.start_with?('before') ? :unshift : :push, block)
         end
         
         # An array of instance level hook blocks for the given hook type.
@@ -143,17 +108,7 @@ module Sequel
         def run_after_instance_hooks(hook)
           instance_hooks(hook).each(&:call)
         end
-
-        # Run all hook blocks of the given hook type.  If a hook block returns false,
-        # immediately return false without running the remaining blocks.
-        def run_before_instance_hooks(hook)
-          instance_hooks(hook).each do |b|
-            if b.call == false
-              Sequel::Deprecation.deprecate("Having #{hook} instance hook block return false to stop evaluation of further #{hook} instance hook blocks", "Instead, call cancel_action inside #{hook} instance hook block")
-              return false
-            end
-          end
-        end
+        alias run_before_instance_hooks run_after_instance_hooks
       end
     end
   end

data/lib/sequel/plugins/inverted_subsets.rb

@@ -18,7 +18,9 @@ module Sequel
     #   Album.plugin :inverted_subsets
     #
     #   # This will now create two methods, published and not_published
-    #   Album.subset :published, :published => true
+    #   Album.dataset_module do
+    #     where :published, published: true
+    #   end
     #
     #   Album.published.sql
     #   # SELECT * FROM albums WHERE (published IS TRUE)

data/lib/sequel/plugins/json_serializer.rb

@@ -17,37 +17,37 @@ module Sequel
     #
     # In addition, you can provide options to control the JSON output:
     #
-    #   album.to_json(:only=>:name)
-    #   album.to_json(:except=>[:id, :artist_id])
+    #   album.to_json(only: :name)
+    #   album.to_json(except: [:id, :artist_id])
     #   # => '{"json_class"="Album","name"=>"RF"}'
     #   
-    #   album.to_json(:include=>:artist)
+    #   album.to_json(include: :artist)
     #   # => '{"id":1,"name":"RF","artist_id":2,
     #   #      "artist":{"id":2,"name":"YJM"}}'
     # 
     # You can use a hash value with <tt>:include</tt> to pass options
     # to associations:
     #
-    #   album.to_json(:include=>{:artist=>{:only=>:name}})
+    #   album.to_json(include: {artist: {only: :name}})
     #   # => '{"id":1,"name":"RF","artist_id":2,
     #   #      "artist":{"name":"YJM"}}'
     #
-    # You can specify a name for a given association by passing <tt>:name</tt>
-    # to the <tt>:include</tt> hash
+    # You can specify a name for a given association by using an aliased
+    # expression as the key in the <tt>:include</tt> hash
     #
-    #   album.to_json(:include=>{Sequel.as(:artist, :singer)=>{:only=>:name}})
+    #   album.to_json(include: {Sequel.as(:artist, :singer)=>{only: :name}})
     #   # => '{"id":1,"name":"RF","artist_id":2,
     #   #      "singer":{"name":"YJM"}}'
     # 
     # You can specify the <tt>:root</tt> option to nest the JSON under the
     # name of the model:
     #
-    #   album.to_json(:root => true)
+    #   album.to_json(root: true)
     #   # => '{"album":{"id":1,"name":"RF","artist_id":2}}'
     #
     # You can specify JSON serialization options to use later:
     #
-    #   album.json_serializer_opts(:root => true)
+    #   album.json_serializer_opts(root: true)
     #   [album].to_json
     #   # => '[{"album":{"id":1,"name":"RF","artist_id":2}}]'
     #
@@ -55,12 +55,12 @@ module Sequel
     # of which return all objects in the dataset:
     #
     #   Album.to_json
-    #   Album.where(:artist_id=>1).to_json(:include=>:tags)
+    #   Album.where(artist_id: 1).to_json(include: :tags)
     #
     # If you have an existing array of model instances you want to convert to
     # JSON, you can call the class to_json method with the :array option:
     #
-    #   Album.to_json(:array=>[Album[1], Album[2]])
+    #   Album.to_json(array: [Album[1], Album[2]])
     #
     # All to_json methods take blocks, and if a block is given, it will yield
     # the array or hash before serialization, and will serialize the value
@@ -77,7 +77,7 @@ module Sequel
     # The array_from_json class method exists to parse arrays of model instances
     # from json:
     #
-    #   json = Album.where(:artist_id=>1).to_json
+    #   json = Album.where(artist_id: 1).to_json
     #   albums = Album.array_from_json(json)
     #
     # These does not necessarily round trip, since doing so would let users
@@ -86,7 +86,7 @@ module Sequel
     # fields, you can use the :fields option, which will call set_fields with
     # the given fields:
     #
-    #   Album.from_json(album.to_json, :fields=>%w'id name')
+    #   Album.from_json(album.to_json, fields: %w'id name')
     #
     # If you want to update an existing instance, you can use the from_json
     # instance method:
@@ -96,11 +96,11 @@ module Sequel
     # Both of these allow creation of cached associated objects, if you provide
     # the :associations option:
     #
-    #   album.from_json(json, :associations=>:artist)
+    #   album.from_json(json, associations: :artist)
     #
     # You can even provide options when setting up the associated objects:
     #
-    #   album.from_json(json, :associations=>{:artist=>{:fields=>%w'id name', :associations=>:tags}})
+    #   album.from_json(json, associations: {artist: {fields: %w'id name', associations: :tags}})
     #
     # Note that active_support/json makes incompatible changes to the to_json API,
     # and breaks some aspects of the json_serializer plugin.  You can undo the damage
@@ -132,7 +132,7 @@ module Sequel
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values.
       def self.configure(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           @json_serializer_opts = (@json_serializer_opts || OPTS).merge(opts)
         end
       end
@@ -276,7 +276,7 @@ module Sequel
         #
         # Example:
         #
-        #   obj.json_serializer_opts(:only=>:name)
+        #   obj.json_serializer_opts(only: :name)
         #   [obj].to_json # => '[{"name":"..."}]'
         def json_serializer_opts(opts=OPTS)
           @json_serializer_opts = Hash[@json_serializer_opts||OPTS].merge!(opts)
@@ -329,7 +329,7 @@ module Sequel
 
                 v = v.empty? ? [] : [v]
 
-                objs = send(k)
+                objs = public_send(k)
 
                 is_array = if r = model.association_reflection(k)
                   r.returns_array?
@@ -351,7 +351,7 @@ module Sequel
                 else
                   key_name = c.to_s
                 end
-                h[key_name] = send(c)
+                h[key_name] = public_send(c)
               end
             end
           end

data/lib/sequel/plugins/lazy_attributes.rb

@@ -13,7 +13,7 @@ module Sequel
     # get the reviews for all of those albums:
     #
     #   Album.plugin :lazy_attributes, :review
-    #   Album.where{id<100}.all do |a|
+    #   Album.where{id < 100}.all do |a|
     #     a.review
     #   end
     #
@@ -38,15 +38,6 @@ module Sequel
       end
       
       module ClassMethods
-        def lazy_attributes_module
-          Sequel::Deprecation.deprecate('Sequel::Model.lazy_attributes_module', 'There is no replacement')
-          @lazy_attributes_module
-        end
-        def lazy_attributes_module=(v)
-          Sequel::Deprecation.deprecate('Sequel::Model.lazy_attributes_module=', 'There is no replacement')
-          @lazy_attributes_module= v
-        end
-
         # Freeze lazy attributes module when freezing model class.
         def freeze
           @lazy_attributes_module.freeze if @lazy_attributes_module

data/lib/sequel/plugins/list.rb

@@ -11,7 +11,7 @@ module Sequel
     #
     #   class Item < Sequel::Model(:items)
     #     plugin :list # will use :position field for position
-    #     plugin :list, :field=>:pos # will use :pos field for position
+    #     plugin :list, field: :pos # will use :pos field for position
     #   end
     #   
     #   item = Item[1]
@@ -38,7 +38,7 @@ module Sequel
     # For example, if each item has a +user_id+ field, and you want every user
     # to have their own list:
     #
-    #   Item.plugin :list, :scope=>:user_id
+    #   Item.plugin :list, scope: :user_id
     # 
     # Note that using this plugin modifies the order of the model's dataset to
     # sort by the position and scope fields.  Also note that this plugin is subject to
@@ -62,7 +62,7 @@ module Sequel
         model.scope_proc = case scope = opts[:scope]
         when Symbol
           model.dataset = model.dataset.order_prepend(scope)
-          proc{|obj| obj.model.where(scope=>obj.send(scope))}
+          proc{|obj| obj.model.where(scope=>obj.public_send(scope))}
         when Array
           model.dataset = model.dataset.order_prepend(*scope)
           proc{|obj| obj.model.where(scope.map{|s| [s, obj.get_column_value(s)]})}
@@ -170,17 +170,17 @@ module Sequel
           self.next(n * -1)
         end
 
-        private
-
         # Set the value of the position_field to the maximum value plus 1 unless the
         # position field already has a value.
-        def _before_validation
+        def before_validation
           unless get_column_value(position_field)
             set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
           end
           super
         end
 
+        private
+
         # The model's position field, an instance method for ease of use.
         def position_field
           model.position_field

data/lib/sequel/plugins/many_through_many.rb

@@ -46,18 +46,18 @@ module Sequel
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :album_id, :artist_id]]
     #
     #   # All albums by artists that are associated to any album that this artist is associated to
-    #   Artist.many_through_many :artist_albums, [[:albums_artists, :artist_id, :album_id], \
-    #    [:albums_artists, :album_id, :artist_id], [:albums_artists, :artist_id, :album_id]], \
-    #    :class=>:Album
+    #   Artist.many_through_many :artist_albums, [[:albums_artists, :artist_id, :album_id],
+    #    [:albums_artists, :album_id, :artist_id], [:albums_artists, :artist_id, :album_id]],
+    #    class: :Album
     #
     #   # All tracks on albums by this artist (also could be a many_to_many)
-    #   Artist.many_through_many :tracks, [[:albums_artists, :artist_id, :album_id]], \
-    #    :right_primary_key=>:album_id
+    #   Artist.many_through_many :tracks, [[:albums_artists, :artist_id, :album_id]],
+    #    right_primary_key: :album_id
     #
     # Often you don't want the current object to appear in the array of associated objects.  This is easiest to handle via an :after_load hook:
     # 
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :album_id, :artist_id]],
-    #     :after_load=>proc{|artist, associated_artists| associated_artists.delete(artist)}
+    #     after_load: lambda{|artist, associated_artists| associated_artists.delete(artist)}
     #
     # You can also handle it by adding a dataset block that excludes the current record (so it won't be retrieved at all), but
     # that won't work when eagerly loading, which is why the :after_load proc is recommended instead.
@@ -65,7 +65,7 @@ module Sequel
     # It's also common to not want duplicate records, in which case the :distinct option can be used:
     # 
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id]],
-    #    :distinct=>true
+    #    distinct: true
     # 
     # In addition to many_through_many, this plugin also adds one_through_many, for an association to a single object through multiple join tables.
     # This is useful if there are unique constraints on the foreign keys in the join tables that reference back to the current table, or if you want
@@ -228,7 +228,10 @@ module Sequel
         def def_many_through_many(opts)
           one_through_many = opts[:type] == :one_through_many
           opts[:read_only] = true
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:cartesian_product_number] ||= one_through_many ? 0 : 2
           opts[:through] = opts[:through].map do |e|
             case e

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -12,15 +12,15 @@ module Sequel
     #   end
     #   p1 = Person[1]
     #   p2 = Person[1]
-    #   p1.update(:name=>'Jim') # works
-    #   p2.update(:name=>'Bob') # raises Sequel::NoExistingObject
+    #   p1.update(name: 'Jim') # works
+    #   p2.update(name: 'Bob') # raises Sequel::NoExistingObject
     #
     # In order for this plugin to work, you need to make sure that the database
     # table has a column of timestamp or rowversion.  The plugin uses a default
     # name of timestamp for this columns, but you can override that using the
     # :lock_column option:
     #
-    #     plugin :mssql_optimistic_locking, :lock_column=>:column_name
+    #     plugin :mssql_optimistic_locking, lock_column: :column_name
     #
     # This plugin relies on the instance_filters plugin.
     module MssqlOptimisticLocking

data/lib/sequel/plugins/nested_attributes.rb

@@ -13,11 +13,11 @@ module Sequel
     # The nested_attributes call defines a single method, <tt><i>association</i>_attributes=</tt>,
     # (e.g. <tt>albums_attributes=</tt>).  So if you have an Artist instance:
     #
-    #   a = Artist.new(:name=>'YJM')
+    #   a = Artist.new(name: 'YJM')
     #
     # You can create new album instances related to this artist:
     #
-    #   a.albums_attributes = [{:name=>'RF'}, {:name=>'MO'}]
+    #   a.albums_attributes = [{name: 'RF'}, {name: 'MO'}]
     #
     # Note that this doesn't send any queries to the database yet.  That doesn't happen till
     # you save the object:
@@ -33,7 +33,7 @@ module Sequel
     # objects.  You just need to make sure that the primary key field is filled in for the
     # associated object:
     #
-    #   a.update(:albums_attributes => [{:id=>1, :name=>'T'}])
+    #   a.update(:albums_attributes => [{id: 1, name: 'T'}])
     #
     # Since the primary key field is filled in, the plugin will update the album with id 1 instead
     # of creating a new album.
@@ -41,15 +41,15 @@ module Sequel
     # If you would like to delete the associated object instead of updating it, you add a _delete
     # entry to the hash, and also pass the :destroy option when calling +nested_attributes+:
     #
-    #   Artist.nested_attributes :albums, :destroy=>true
-    #   a.update(:albums_attributes => [{:id=>1, :_delete=>true}])
+    #   Artist.nested_attributes :albums, destroy: true
+    #   a.update(:albums_attributes => [{id: 1, _delete: true}])
     #
     # This will delete the related associated object from the database.  If you want to leave the
     # associated object in the database, but just remove it from the association, add a _remove
     # entry in the hash, and also pass the :remove option when calling +nested_attributes+:
     #
-    #   Artist.nested_attributes :albums, :remove=>true
-    #   a.update(:albums_attributes => [{:id=>1, :_remove=>true}])
+    #   Artist.nested_attributes :albums, remove: true
+    #   a.update(:albums_attributes => [{id: 1, _remove: true}])
     #
     # The above example was for a one_to_many association, but the plugin also works similarly
     # for other association types.  For one_to_one and many_to_one associations, you need to
@@ -66,11 +66,11 @@ module Sequel
     #
     # Your web stack will probably parse that into a nested hash similar to:
     #
-    #   {:artist=>{:name=>'Y', :albums_attributes=>{0=>{:name=>'X'}, 1=>{:id=>'2', :name=>'Z'}}}}
+    #   {'artist'=>{'name'=>'Y', 'albums_attributes'=>{'0'=>{'name'=>'X'}, '1'=>{'id'=>'2', 'name'=>'Z'}}}}
     #
     # Then you can do:
     #
-    #   artist.update_fields(params[:artist], [:name, :albums_artists])
+    #   artist.update_fields(params['artist'], %w'name albums_artists')
     #
     # To save changes to the artist, create the first album and associate it to the artist,
     # and update the other existing associated album.
@@ -81,15 +81,6 @@ module Sequel
       end
       
       module ClassMethods
-        def nested_attributes_module
-          Sequel::Deprecation.deprecate('Sequel::Model.nested_attributes_module', 'There is no replacement')
-          @nested_attributes_module
-        end
-        def nested_attributes_module=(v)
-          Sequel::Deprecation.deprecate('Sequel::Model.nested_attributes_module=', 'There is no replacement')
-          @nested_attributes_module = v
-        end
-        
         # Freeze nested_attributes_module when freezing model class.
         def freeze
           @nested_attributes_module.freeze if @nested_attributes_module
@@ -127,11 +118,7 @@ module Sequel
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|
             r[:nested_attributes] = opts
-            r[:nested_attributes][:unmatched_pk] ||= (
-              if opts.has_key?(:strict)
-                Sequel::Deprecation.deprecate("The nested_attributes :strict option", "Use the :unmatched_pk option instead")
-              end
-              opts.delete(:strict) == false ? :ignore : :raise)
+            r[:nested_attributes][:unmatched_pk] ||= :raise
             r[:nested_attributes][:reject_if] ||= block
             def_nested_attribute_method(r)
           end
@@ -188,8 +175,8 @@ module Sequel
           nested_attributes_set_attributes(meta, obj, attributes)
           delay_validate_associated_object(reflection, obj)
           if reflection.returns_array?
-            send(reflection[:name]) << obj
-            after_save_hook{send(reflection.add_method, obj)}
+            public_send(reflection[:name]) << obj
+            after_save_hook{public_send(reflection[:add_method], obj)}
           else
             associations[reflection[:name]] = obj
 
@@ -201,9 +188,9 @@ module Sequel
             # Don't need to validate the object twice if :validate association option is not false
             # and don't want to validate it at all if it is false.
             if reflection[:type] == :many_to_one 
-              before_save_hook{send(reflection.setter_method, obj.save(:validate=>false))}
+              before_save_hook{public_send(reflection[:setter_method], obj.save(:validate=>false))}
             else
-              after_save_hook{send(reflection.setter_method, obj)}
+              after_save_hook{public_send(reflection[:setter_method], obj)}
             end
           end
           add_reciprocal_object(reflection, obj)
@@ -215,7 +202,7 @@ module Sequel
         # If there is a limit on the nested attributes for this association,
         # make sure the length of the attributes_list is not greater than the limit.
         def nested_attributes_list_setter(meta, attributes_list)
-          attributes_list = attributes_list.sort_by(&:to_s).map{|k,v| v} if attributes_list.is_a?(Hash)
+          attributes_list = attributes_list.sort.map{|k,v| v} if attributes_list.is_a?(Hash)
           if (limit = meta[:limit]) && attributes_list.length > limit
             raise(Error, "number of nested attributes (#{attributes_list.length}) exceeds the limit (#{limit})")
           end
@@ -231,9 +218,9 @@ module Sequel
           if !opts[:destroy] || reflection.remove_before_destroy?
             before_save_hook do
               if reflection.returns_array?
-                send(reflection.remove_method, obj)
+                public_send(reflection[:remove_method], obj)
               else
-                send(reflection.setter_method, nil)
+                public_send(reflection[:setter_method], nil)
               end
             end
           end
@@ -277,7 +264,7 @@ module Sequel
           str_keys = sym_keys.map(&:to_s)
           if (pk = attributes.values_at(*sym_keys)).all? || (pk = attributes.values_at(*str_keys)).all?
             pk = pk.map(&:to_s)
-            obj = Array(send(reflection[:name])).find{|x| Array(x.pk).map(&:to_s) == pk}
+            obj = Array(public_send(reflection[:name])).find{|x| Array(x.pk).map(&:to_s) == pk}
           end
           if obj
             attributes = attributes.dup.delete_if{|k,v| str_keys.include? k.to_s}

data/lib/sequel/plugins/optimistic_locking.rb

@@ -11,11 +11,11 @@ module Sequel
     #   end
     #   p1 = Person[1]
     #   p2 = Person[1]
-    #   p1.update(:name=>'Jim') # works
-    #   p2.update(:name=>'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
+    #   p1.update(name: 'Jim') # works
+    #   p2.update(name: 'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
     #
     # In order for this plugin to work, you need to make sure that the database
-    # table has a lock_version column (or other column you name via the lock_column
+    # table has a +lock_version+ column (or other column you name via the lock_column
     # class level accessor) that defaults to 0.
     #
     # This plugin relies on the instance_filters plugin.

data/lib/sequel/plugins/pg_array_associations.rb

@@ -328,7 +328,10 @@ module Sequel
           opts[:key] = opts.default_key unless opts.has_key?(:key)
           key = opts[:key]
           key_column = opts[:key_column] ||= opts[:key]
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:dataset] ||= lambda do
             opts.associated_dataset.where(Sequel.pg_array_op(opts.predicate_key).contains(Sequel.pg_array([get_column_value(pk)], opts.array_type)))
           end
@@ -408,7 +411,10 @@ module Sequel
           key = opts[:key]
           key_column = opts[:key_column] ||= key
           opts[:eager_loader_key] = nil
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:dataset] ||= lambda do
             opts.associated_dataset.where(opts.predicate_key=>get_column_value(key).to_a)
           end

data/lib/sequel/plugins/pg_row.rb

@@ -41,22 +41,13 @@ module Sequel
     #
     #   Address.register_row_type
     #
-    # Note that automatic conversion only works with the native postgres adapter.
-    # For other adapters that connect to PostgreSQL, you need to call the conversion
-    # proc manually.
-    #
     # In addition to returning row-valued/composite types as instances of Sequel::Model,
     # this also lets you use model instances in datasets when inserting, updating, and
     # filtering:
     #
-    #   DB[:company].insert(:name=>'MS', :address=>
-    #     Address.load(:street=>'123 Foo St', :city=>'Bar Town', :zip=>'12345'))
+    #   DB[:company].insert(name: 'MS', address:
+    #     Address.load(street: '123 Foo St', city: 'Bar Town', zip: '12345'))
     module PgRow
-      ROW = 'ROW'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :ROW)
-      CAST = '::'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CAST)
-
       # When loading the extension, make sure the database has the pg_row extension
       # loaded, load the custom database extensions, and automatically register the
       # row type if the model has a dataset.