sequel 4.46.0 → 4.49.0

data/lib/sequel/plugins/column_conflicts.rb

@@ -29,11 +29,16 @@ module Sequel
     #   # Make the Album class handle column conflicts automatically
     #   Album.plugin :column_conflicts
     module ColumnConflicts
-      # Check for column conflicts on the current model if the model has a dataset.
-      def self.configure(model)
+      def self.apply(model)
         model.instance_eval do
           @get_column_conflicts = {}
           @set_column_conflicts = {}
+        end
+      end
+
+      # Check for column conflicts on the current model if the model has a dataset.
+      def self.configure(model)
+        model.instance_eval do
           check_column_conflicts if @dataset
         end
       end

data/lib/sequel/plugins/column_select.rb

@@ -41,15 +41,15 @@ module Sequel
         # qualifying them with table's name.
         def convert_input_dataset(ds)
           ds = super
-          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join]
+          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join] # SEQUE5: just !ds.opts[:select]
             if db.supports_schema_parsing?
-              cols = check_non_connection_error{db.schema(ds)}
+              cols = check_non_connection_error(false){db.schema(ds)}
               if cols
                 cols = cols.map{|c, _| c}
               end
             end
 
-            if cols ||= check_non_connection_error{ds.columns}
+            if cols ||= check_non_connection_error(false){ds.columns}
               ds = ds.select(*cols.map{|c| Sequel.qualify(ds.first_source, Sequel.identifier(c))})
             end
           end

data/lib/sequel/plugins/composition.rb

@@ -123,9 +123,9 @@ module Sequel
               setters = setter_meths.zip(cov_methods)
               opts[:decomposer] = proc do
                 if (o = compositions[name]).nil?
-                  setter_meths.each{|sm| get_column_value(sm, nil)}
+                  setter_meths.each{|sm| set_column_value(sm, nil)}
                 else
-                  setters.each{|sm, cm| get_column_value(sm, o.send(cm))}
+                  setters.each{|sm, cm| set_column_value(sm, o.send(cm))}
                 end
               end
             end

data/lib/sequel/plugins/csv_serializer.rb

@@ -76,9 +76,9 @@ 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 = {})
+      def self.configure(model, opts = OPTS)
         model.instance_eval do
-          @csv_serializer_opts = (@csv_serializer_opts || {}).merge(opts)
+          @csv_serializer_opts = (@csv_serializer_opts || OPTS).merge(opts)
         end
       end
 
@@ -87,7 +87,7 @@ module Sequel
         attr_reader :csv_serializer_opts
 
         # Attempt to parse an array of instances from the given CSV string
-        def array_from_csv(csv, opts = {})
+        def array_from_csv(csv, opts = OPTS)
           CSV.parse(csv, process_csv_serializer_opts(opts)).map do |row|
             row = row.to_hash
             row.delete(nil)
@@ -105,13 +105,13 @@ module Sequel
         end
 
         # Attempt to parse a single instance from the given CSV string
-        def from_csv(csv, opts = {})
+        def from_csv(csv, opts = OPTS)
           new.from_csv(csv, opts)
         end
 
         # Convert the options hash to one that can be passed to CSV.
         def process_csv_serializer_opts(opts)
-          opts = (csv_serializer_opts || {}).merge(opts)
+          opts = (csv_serializer_opts || OPTS).merge(opts)
           opts_cols = opts.delete(:columns)
           opts_include = opts.delete(:include)
           opts_except = opts.delete(:except)
@@ -136,7 +136,7 @@ module Sequel
         #
         # :headers :: The headers to use for the CSV line. Use nil for a header
         #             to specify the column should be ignored.
-        def from_csv(csv, opts = {})
+        def from_csv(csv, opts = OPTS)
           row = CSV.parse_line(csv, model.process_csv_serializer_opts(opts)).to_hash
           row.delete(nil)
           set(row)
@@ -151,7 +151,7 @@ module Sequel
         #          output, ignoring all other columns
         # :include :: Symbol or Array of Symbols specifying non-column
         #             attributes to include in the CSV output.
-        def to_csv(opts = {})
+        def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts(opts)
 
           CSV.generate(opts) do |csv|
@@ -168,7 +168,7 @@ module Sequel
         #
         # :array :: An array of instances.  If this is not provided, calls #all
         #           on the receiver to get the array.
-        def to_csv(opts = {})
+        def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts({:columns=>columns}.merge!(opts))
           items = opts.delete(:array) || self
 

data/lib/sequel/plugins/dataset_associations.rb

@@ -93,22 +93,34 @@ module Sequel
               where(r.qualify(r.join_table_alias, r[:left_keys])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
             ds.where(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :many_through_many, :one_through_many
-            fe, *edges = r.edges
-            edges << r.final_edge
-            if fre = r.reverse_edges.first
-              table = fre[:table]
-              left = fre[:left]
-              mds = model.join(fe[:table], Array(fe[:right]).zip(Array(fe[:left])), :implicit_qualifier=>model.table_name)
-            else
-              table = fe[:table]
-              left = edges.first[:left]
-              edges = []
+            if r.reverse_edges.empty?
               mds = r.associated_dataset
+              fe = r.edges.first
+              selection = Array(r.qualify(fe[:table], r.final_edge[:left]))
+              predicate_key = r.qualify(fe[:table], fe[:right])
+            else
+              mds = model.dataset
+              iq = model.table_name
+              edges = r.edges.map(&:dup)
+              edges << r.final_edge.dup
+              edges.each do |e|
+                alias_expr = e[:table]
+                aliaz = mds.unused_table_alias(e[:table])
+                unless aliaz == alias_expr
+                  alias_expr = Sequel.as(e[:table], aliaz)
+                end
+                e[:alias] = aliaz
+                mds = mds.join(alias_expr, Array(e[:right]).zip(Array(e[:left])), :implicit_qualifier=>iq)
+                iq = nil
+              end
+              fe, f1e, f2e = edges.values_at(0, -1, -2)
+              selection = Array(r.qualify(f2e[:alias], f1e[:left]))
+              predicate_key = r.qualify(fe[:alias], fe[:right])
             end
+
             mds = mds.
-              select(*Array(r.qualify(table, left))).
-              where(r.qualify(fe[:table], fe[:right])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
-            edges.each{|e| mds = mds.join(e[:table], Array(e[:right]).zip(Array(e[:left])))}
+              select(*selection).
+              where(predicate_key=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
             ds.where(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :pg_array_to_many
             ds.where(Sequel[r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}])

data/lib/sequel/plugins/defaults_setter.rb

@@ -13,6 +13,16 @@ module Sequel
     #   album = Album.new(:a=>1, :b=>3)
     #   album.a # => 1
     #   album.b # => 3
+    #
+    # You can manually set default values as well:
+    #
+    #   Album.default_values[:a] = 4
+    #   Album.new.a # => 4
+    #
+    # You can also provide procs to set default values:
+    #
+    #   Album.default_values[:a] = lambda{Date.today}
+    #   Album.new.a # => Date.today
     # 
     # Usage:
     #
@@ -36,6 +46,8 @@ module Sequel
         
         Plugins.after_set_dataset(self, :set_default_values)
 
+        Plugins.inherited_instance_variables(self, :@default_values=>:dup)
+
         # Freeze default values when freezing model class
         def freeze
           @default_values.freeze
@@ -48,7 +60,7 @@ module Sequel
         def set_default_values
           h = {}
           @db_schema.each{|k, v| h[k] = convert_default_value(v[:ruby_default]) unless v[:ruby_default].nil?} if @db_schema
-          @default_values = h
+          @default_values = h.merge!(@default_values || {})
         end
 
         # Handle the CURRENT_DATE and CURRENT_TIMESTAMP values specially by returning an appropriate Date or

data/lib/sequel/plugins/eager_each.rb

@@ -39,7 +39,7 @@ module Sequel
         end
 
         # Call #all instead of #each if eager loading,
-        # uless #each is being called by #all.
+        # unless #each is being called by #all.
         def each(&block)
           if use_eager_all?
             all(&block)

data/lib/sequel/plugins/force_encoding.rb

@@ -14,11 +14,11 @@ module Sequel
     #
     # Usage:
     #
-    #   # Force all strings to be UTF8 encoded in a all model subclasses
+    #   # Force all strings to be UTF-8 encoded in a all model subclasses
     #   # (called before loading subclasses)
     #   Sequel::Model.plugin :force_encoding, 'UTF-8'
     #
-    #   # Force the encoding for the Album model to UTF8
+    #   # Force the encoding for the Album model to UTF-8
     #   Album.plugin :force_encoding
     #   Album.forced_encoding = 'UTF-8'
     module ForceEncoding

data/lib/sequel/plugins/hook_class_methods.rb

@@ -2,10 +2,10 @@
 
 module Sequel
   module Plugins
-    # Sequel's built-in hook class methods plugin is designed for backwards
+    # Sequel's built-in hook_class_methods plugin is designed for backwards
     # compatibility.  Its use is not encouraged, it is recommended to use
-    # instance methods and super instead of this plugin.  What this plugin
-    # allows you to do is, for example:
+    # instance methods and super instead of this plugin.  This plugin allows
+    # calling class methods with blocks to define hooks:
     #
     #   # Block only, can cause duplicate hooks if code is reloaded
     #   before_save{self.created_at = Time.now}
@@ -15,17 +15,14 @@ module Sequel
     #   before_save(:set_created_at)
     #
     # Pretty much anything you can do with a hook class method, you can also
-    # do with an instance method instead:
+    # do with an instance method instead (making sure to call super), which is
+    # the recommended way to add hooks in Sequel:
     #
     #    def before_save
-    #      return false if super == false
+    #      super
     #      self.created_at = Time.now
     #    end
     #
-    # Note that returning false in any before hook block will skip further
-    # before hooks and abort the action.  So if a before_save hook block returns
-    # false, future before_save hook blocks are not called, and the save is aborted.
-    # 
     # Usage:
     #
     #   # Allow use of hook class methods in all model subclasses (called before loading subclasses)
@@ -91,7 +88,6 @@ module Sequel
         # arbitrary code execution.
         def add_hook_type(*hooks)
           Sequel::Deprecation.deprecate("Sequel::Model.add_hook_type", "You should add your own hook types manually")
-          Model::HOOKS.concat(hooks)
           hooks.each do |hook|
             @hooks[hook] = []
             instance_eval("def #{hook}(method = nil, &block); add_hook(:#{hook}, method, &block) end", __FILE__, __LINE__)
@@ -141,7 +137,8 @@ module Sequel
       end
 
       module InstanceMethods
-        (Model::BEFORE_HOOKS - [:before_save, :before_destroy]).each do |h|
+        # SEQUEL5: Make :before_save, :before_destroy, :after_save, :after_destroy hooks use metaprogramming instead of specific definitions
+        [:before_create, :before_update, :before_validation].each do |h|
           class_eval(<<-END, __FILE__, __LINE__+1)
             def #{h}
               model.hook_blocks(:#{h}) do |b|
@@ -154,7 +151,7 @@ module Sequel
             end
           END
         end
-        (Model::AFTER_HOOKS - [:after_save, :after_destroy, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]).each{|h| class_eval("def #{h}; super; model.hook_blocks(:#{h}){|b| instance_eval(&b)}; end", __FILE__, __LINE__)}
+        [:after_create, :after_update, :after_validation].each{|h| class_eval("def #{h}; super; model.hook_blocks(:#{h}){|b| instance_eval(&b)}; end", __FILE__, __LINE__)}
 
         def after_destroy
           super

data/lib/sequel/plugins/identifier_columns.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+Sequel::Deprecation.deprecate("The identifier_columns plugin", "Set Sequel.split_symbols = false instead")
+
 module Sequel
   module Plugins
     # The identifier_columns plugin makes Sequel automatically

data/lib/sequel/plugins/instance_filters.rb

@@ -7,7 +7,9 @@ module Sequel
     # where you would normally have to drop down to the dataset level
     # to get the necessary control, because you only want to delete or
     # update the rows in certain cases based on the current status of
-    # the row in the database.
+    # the row in the database.  The main purpose of this plugin is to
+    # avoid race conditions by relying on the atomic properties of database
+    # transactions.
     # 
     #   class Item < Sequel::Model
     #     plugin :instance_filters

data/lib/sequel/plugins/instance_hooks.rb

@@ -9,8 +9,7 @@ module Sequel
     # All of the standard hooks are supported.
     # Instance level before hooks are executed in reverse order of addition before
     # calling super.  Instance level after hooks are executed in order of addition
-    # after calling super.  If any of the instance level before hook blocks return
-    # false, no more instance level before hooks are called and false is returned.
+    # after calling super.
     #
     # Instance level hooks for before and after are cleared after all related
     # after level instance hooks have run.  This means that if you add a before_create
@@ -29,9 +28,12 @@ module Sequel
     #   # Add the instance hook methods just to Album instances
     #   Album.plugin :instance_hooks
     module InstanceHooks
-      BEFORE_HOOKS = Sequel::Model::BEFORE_HOOKS
-      AFTER_HOOKS = Sequel::Model::AFTER_HOOKS
-      HOOKS = BEFORE_HOOKS + AFTER_HOOKS
+      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",
@@ -41,7 +43,7 @@ module Sequel
       }.freeze
 
       module InstanceMethods 
-        HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
+        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?
@@ -50,8 +52,8 @@ module Sequel
           end
         END
         
-        (BEFORE_HOOKS - [:before_destroy, :before_save]).each{|h| class_eval("def #{h}; (@instance_hooks && run_before_instance_hooks(:#{h}) == false) ? false : super end", __FILE__, __LINE__)}
-        (AFTER_HOOKS - [:after_validation, :after_save, :after_destroy, :after_commit, :after_destroy_commit, :after_destroy_rollback, :after_rollback]).each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
+        [: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__)}
+        [:after_create, :after_update].each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
           def #{h}
             super
             return unless @instance_hooks
@@ -65,6 +67,7 @@ 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
@@ -86,6 +89,7 @@ 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
@@ -101,18 +105,22 @@ module Sequel
         # 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
         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
         end
         
@@ -122,7 +130,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(BEFORE_HOOKS.include?(hook) ? :unshift : :push, block)
+          instance_hooks(hook).send(hook.to_s.start_with?('before') ? :unshift : :push, block)
         end
         
         # An array of instance level hook blocks for the given hook type.

data/lib/sequel/plugins/json_serializer.rb

@@ -62,6 +62,11 @@ module Sequel
     #
     #   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
+    # the block returns.  This allows you to customize the resulting JSON format
+    # on a per-call basis.
+    #
     # In addition to creating JSON, this plugin also enables Sequel::Model
     # classes to create instances directly from JSON using the from_json class
     # method:
@@ -126,9 +131,9 @@ module Sequel
     module JsonSerializer
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values.
-      def self.configure(model, opts={})
+      def self.configure(model, opts=OPTS)
         model.instance_eval do
-          @json_serializer_opts = (@json_serializer_opts || {}).merge(opts)
+          @json_serializer_opts = (@json_serializer_opts || OPTS).merge(opts)
         end
       end
       
@@ -222,10 +227,10 @@ module Sequel
           if assocs = opts[:associations]
             assocs = case assocs
             when Symbol
-              {assocs=>{}}
+              {assocs=>OPTS}
             when Array
               assocs_tmp = {}
-              assocs.each{|v| assocs_tmp[v] = {}}
+              assocs.each{|v| assocs_tmp[v] = OPTS}
               assocs_tmp
             when Hash
               assocs
@@ -316,7 +321,7 @@ module Sequel
             if inc.is_a?(Hash)
               inc.each do |k, v|
                 if k.is_a?(Sequel::SQL::AliasedExpression)
-                  key_name = k.aliaz.to_s
+                  key_name = k.alias.to_s
                   k = k.expression
                 else
                   key_name = k.to_s
@@ -341,7 +346,7 @@ module Sequel
             else
               Array(inc).each do |c|
                 if c.is_a?(Sequel::SQL::AliasedExpression)
-                  key_name = c.aliaz.to_s
+                  key_name = c.alias.to_s
                   c = c.expression
                 else
                   key_name = c.to_s
@@ -358,6 +363,7 @@ module Sequel
             h = {root => h}
           end
 
+          h = yield h if block_given?
           Sequel.object_to_json(h, *a)
         end
       end
@@ -370,6 +376,8 @@ module Sequel
         #
         # :array :: An array of instances.  If this is not provided,
         #           calls #all on the receiver to get the array.
+        # :instance_block :: A block to pass to #to_json for each
+        #                    value in the dataset (or :array option).
         # :root :: If set to :collection, wraps the collection
         #          in a root object using the pluralized, underscored model
         #          name as the key.  If set to :instance, only wraps
@@ -405,16 +413,15 @@ module Sequel
             else
               all
             end
-            array.map{|obj| Literal.new(Sequel.object_to_json(obj, opts))}
+            array.map{|obj| Literal.new(Sequel.object_to_json(obj, opts, &opts[:instance_block]))}
            else
             all
           end
 
-          if collection_root
-            Sequel.object_to_json({collection_root => res}, *a)
-          else
-            Sequel.object_to_json(res, *a)
-          end
+          res = {collection_root => res} if collection_root
+          res = yield res if block_given?
+
+          Sequel.object_to_json(res, *a)
         end
       end
     end

data/lib/sequel/plugins/lazy_attributes.rb

@@ -92,9 +92,8 @@ module Sequel
         # the attribute for just the current object.  Return the value of
         # the attribute for the current object.
         def lazy_attribute_lookup(a, opts=OPTS)
-          unless table = opts[:table]
-            table = model.table_name
-          end
+          table = opts[:table] || model.table_name
+          selection = Sequel.qualify(table, a)
 
           if base_ds = opts[:dataset]
             ds = base_ds.where(qualified_pk_hash(table))
@@ -103,10 +102,8 @@ module Sequel
             ds = this
           end
 
-          selection = Sequel.qualify(table, a)
-
           if frozen?
-            return ds.dup.get(selection)
+            return ds.get(selection)
           end
 
           if retrieved_with
@@ -115,7 +112,11 @@ module Sequel
             id_map = {}
             retrieved_with.each{|o| id_map[o.pk] = o unless o.values.has_key?(a) || o.frozen?}
             predicate_key = composite_pk ? primary_key.map{|k| Sequel.qualify(table, k)} : Sequel.qualify(table, primary_key)
-            base_ds.select(*(Array(primary_key).map{|k| Sequel.qualify(table, k)} + [selection])).where(predicate_key=>id_map.keys).naked.each do |row|
+            base_ds.
+             select(*(Array(primary_key).map{|k| Sequel.qualify(table, k)} + [selection])).
+             where(predicate_key=>id_map.keys).
+             naked.
+             each do |row|
               obj = id_map[composite_pk ? row.values_at(*primary_key) : row[primary_key]]
               if obj && !obj.values.has_key?(a)
                 obj.values[a] = row[a]

data/lib/sequel/plugins/many_to_one_pk_lookup.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+Sequel::Deprecation.deprecate("The many_to_one_pk_lookup plugin", "This plugin was integrated into the default model behavior in Sequel 4.0, and no longer has an effect")
+
 module Sequel
   module Plugins
     # Empty plugin module for backwards compatibility

data/lib/sequel/plugins/modification_detection.rb

@@ -17,6 +17,9 @@ module Sequel
     # Note that for this plugin to work correctly, the column values must
     # correctly implement the #hash method, returning the same value if
     # the object is equal, and a different value if the object is not equal.
+    # As this solely uses hash values to check for modification, there may
+    # be cases where a modification is made and the hash value is the same,
+    # resulting in a false negative.
     #
     # Note that this plugin causes a performance hit for all retrieved
     # objects, so it shouldn't be used in cases where performance is a

data/lib/sequel/plugins/nested_attributes.rb

@@ -70,7 +70,7 @@ module Sequel
     #
     # Then you can do:
     #
-    #   artist.update(params[:artist])
+    #   artist.update_fields(params[:artist], [: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.
@@ -127,7 +127,11 @@ 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] ||= opts.delete(:strict) == false ? :ignore : :raise
+            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][:reject_if] ||= block
             def_nested_attribute_method(r)
           end

data/lib/sequel/plugins/pg_array_associations.rb

@@ -297,6 +297,11 @@ module Sequel
         end
       end
 
+      # Add the pg_array extension to the database
+      def self.apply(model)
+        model.db.extension(:pg_array)
+      end
+
       module ClassMethods
         # Create a many_to_pg_array association, for the case where the associated
         # table contains the array with foreign keys pointing to the current table.

data/lib/sequel/plugins/pg_row.rb

@@ -53,7 +53,9 @@ module Sequel
     #     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
@@ -75,9 +77,9 @@ module Sequel
       module InstanceMethods
         # Literalize the model instance and append it to the sql.
         def sql_literal_append(ds, sql)
-          sql << ROW
+          sql << 'ROW'
           ds.literal_append(sql, values.values_at(*columns))
-          sql << CAST
+          sql << '::'
           ds.quote_schema_table_append(sql, model.dataset.first_source_table)
         end
       end

data/lib/sequel/plugins/pg_typecast_on_load.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+Sequel::Deprecation.deprecate("The pg_typecast_on_load plugin", "This plugin is only useful on the deprecated do and switch adapters")
+
 module Sequel
   module Plugins
     # The PgTypecastOnLoad plugin exists because when you connect to PostgreSQL

data/lib/sequel/plugins/prepared_statements.rb

@@ -225,6 +225,7 @@ module Sequel
           case type
           when :insert, :insert_select, :update
             true
+          # SEQUEL5: Remove :delete/:refresh
           when :delete
             return true unless model.fast_instance_delete_sql