sequel 4.46.0 → 4.49.0

data/lib/sequel/database/misc.rb

@@ -31,7 +31,7 @@ module Sequel
     module ResetIdentifierMangling
       def self.extended(obj)
         # :nocov:
-        Sequel::Deprecation.deprecate("Sequel::Database::ResetIdentifierMangling is no longer needed and will be removed in Sequel 5.  Please update your adapter.")
+        Sequel::Deprecation.deprecate("Sequel::Database::ResetIdentifierMangling is no longer needed and will be removed in Sequel 5.  Please update your adapter")
         obj.send(:reset_identifier_mangling) if obj.respond_to?(:reset_identifier_mangling)
         # :nocov:
       end

data/lib/sequel/database/query.rb

@@ -310,6 +310,9 @@ module Sequel
 
     # Remove the cached schema for the given schema name
     def remove_cached_schema(table)
+      #SEQUEL5
+      #cache = @default_dataset.send(:cache)
+      #Sequel.synchronize{cache.clear}
       k = quote_schema_table(table)
       Sequel.synchronize{@schemas.delete(k)}
     end

data/lib/sequel/database/schema_methods.rb

@@ -707,7 +707,7 @@ module Sequel
       e = options[:ignore_index_errors] || options[:if_not_exists]
       generator.indexes.each do |index|
         begin
-          index_sql_list(name, [index]).each{|sql| execute_ddl(sql)}
+          transaction(:savepoint=>:only){index_sql_list(name, [index]).each{|sql| execute_ddl(sql)}}
         rescue Error
           raise unless e
         end

data/lib/sequel/dataset/actions.rb

@@ -11,11 +11,13 @@ module Sequel
     
     # Action methods defined by Sequel that execute code on the database.
     ACTION_METHODS = (<<-METHS).split.map(&:to_sym).freeze
-      << [] all avg count columns columns! delete each
+      << [] all as_hash avg count columns columns! delete each
       empty? fetch_rows first first! get import insert interval last
       map max min multi_insert paged_each range select_hash select_hash_groups select_map select_order_map
       single_record single_record! single_value single_value! sum to_hash to_hash_groups truncate update
+      where_all where_each where_single_value
     METHS
+    # SEQUEL5: Remove interval, range
 
     # The clone options to use when retriveing columns for a dataset.
     COLUMNS_CLONE_OPTIONS = {:distinct => nil, :limit => 1, :offset=>nil, :where=>nil, :having=>nil, :order=>nil, :row_proc=>nil, :graph=>nil, :eager_graph=>nil}.freeze
@@ -410,6 +412,7 @@ module Sequel
     #   DB[:table].interval{function(column)} # SELECT (max(function(column)) - min(function(column))) FROM table LIMIT 1
     #   # => 7
     def interval(column=Sequel.virtual_row(&Proc.new))
+      Sequel::Deprecation.deprecate("Sequel::Dataset#interval", "Use #max - #min, or use the sequel_4_dataset_methods extension")
       if loader = cached_placeholder_literalizer(:_interval_loader) do |pl|
           arg = pl.arg
           aggregate_dataset.limit(1).select((SQL::Function.new(:max, arg) - SQL::Function.new(:min, arg)).as(:interval))
@@ -623,6 +626,7 @@ module Sequel
     #   DB[:table].interval{function(column)} # SELECT max(function(column)) AS v1, min(function(column)) AS v2 FROM table LIMIT 1
     #   # => 0..7
     def range(column=Sequel.virtual_row(&Proc.new))
+      Sequel::Deprecation.deprecate("Sequel::Dataset#range", "Use #min..#max, or use the sequel_4_dataset_methods extension")
       r = if loader = cached_placeholder_literalizer(:_range_loader) do |pl|
             arg = pl.arg
             aggregate_dataset.limit(1).select(SQL::Function.new(:min, arg).as(:v1), SQL::Function.new(:max, arg).as(:v2))
@@ -639,8 +643,8 @@ module Sequel
     end
     
     # Returns a hash with key_column values as keys and value_column values as
-    # values.  Similar to to_hash, but only selects the columns given.  Like
-    # to_hash, it accepts an optional :hash parameter, into which entries will
+    # values.  Similar to as_hash, but only selects the columns given.  Like
+    # as_hash, it accepts an optional :hash parameter, into which entries will
     # be merged. 
     #
     #   DB[:table].select_hash(:id, :name) # SELECT id, name FROM table
@@ -656,7 +660,7 @@ module Sequel
     # that Sequel can determine.  Usually you can do this by calling the #as method
     # on the expression and providing an alias.
     def select_hash(key_column, value_column, opts = OPTS)
-      _select_hash(:to_hash, key_column, value_column, opts)
+      _select_hash(:as_hash, key_column, value_column, opts)
     end
     
     # Returns a hash with key_column values as keys and an array of value_column values.
@@ -786,19 +790,19 @@ module Sequel
     # will overwrite the value of the previous row(s). If the value_column
     # is not given or nil, uses the entire hash as the value.
     #
-    #   DB[:table].to_hash(:id, :name) # SELECT * FROM table
+    #   DB[:table].as_hash(:id, :name) # SELECT * FROM table
     #   # {1=>'Jim', 2=>'Bob', ...}
     #
-    #   DB[:table].to_hash(:id) # SELECT * FROM table
+    #   DB[:table].as_hash(:id) # SELECT * FROM table
     #   # {1=>{:id=>1, :name=>'Jim'}, 2=>{:id=>2, :name=>'Bob'}, ...}
     #
     # You can also provide an array of column names for either the key_column,
     # the value column, or both:
     #
-    #   DB[:table].to_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
+    #   DB[:table].as_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
     #   # {[1, 3]=>['Jim', 'bo'], [2, 4]=>['Bob', 'be'], ...}
     #
-    #   DB[:table].to_hash([:id, :name]) # SELECT * FROM table
+    #   DB[:table].as_hash([:id, :name]) # SELECT * FROM table
     #   # {[1, 'Jim']=>{:id=>1, :name=>'Jim'}, [2, 'Bob']=>{:id=>2, :name=>'Bob'}, ...}
     #
     # Options:
@@ -806,11 +810,11 @@ module Sequel
     # :hash :: The object into which the values will be placed.  If this is not
     #          given, an empty hash is used.  This can be used to use a hash with
     #          a default value or default proc.
-    def to_hash(key_column, value_column = nil, opts = OPTS)
+    def as_hash(key_column, value_column = nil, opts = OPTS)
       h = opts[:hash] || {}
       meth = opts[:all] ? :all : :each
       if value_column
-        return naked.to_hash(key_column, value_column, opts) if row_proc
+        return naked.as_hash(key_column, value_column, opts) if row_proc
         if value_column.is_a?(Array)
           if key_column.is_a?(Array)
             send(meth){|r| h[r.values_at(*key_column)] = r.values_at(*value_column)}
@@ -832,6 +836,11 @@ module Sequel
       h
     end
 
+    # Alias of as_hash for backwards compatibility.
+    def to_hash(*a)
+      as_hash(*a)
+    end
+
     # Returns a hash with one column used as key and the values being an
     # array of column values. If the value_column is not given or nil, uses
     # the entire hash as the value.
@@ -909,6 +918,52 @@ module Sequel
       end
     end
 
+    # Return an array of all rows matching the given filter condition, also
+    # yielding each row to the given block.  Basically the same as where(cond).all(&block),
+    # except it can be optimized to not create an intermediate dataset.
+    #
+    #   DB[:table].where_all(:id=>[1,2,3])
+    #   # SELECT * FROM table WHERE (id IN (1, 2, 3))
+    def where_all(cond, &block)
+      if loader = _where_loader
+        loader.all(filter_expr(cond), &block)
+      else
+        where(cond).all(&block)
+      end
+    end
+
+    # Iterate over all rows matching the given filter condition, 
+    # yielding each row to the given block.  Basically the same as where(cond).each(&block),
+    # except it can be optimized to not create an intermediate dataset.
+    #
+    #   DB[:table].where_each(:id=>[1,2,3]){|row| p row}
+    #   # SELECT * FROM table WHERE (id IN (1, 2, 3))
+    def where_each(cond, &block)
+      if loader = _where_loader
+        loader.each(filter_expr(cond), &block)
+      else
+        where(cond).each(&block)
+      end
+    end
+
+    # Filter the datasets using the given filter condition, then return a single value.
+    # This assumes that the dataset has already been setup to limit the selection to
+    # a single column.  Basically the same as where(cond).single_value,
+    # except it can be optimized to not create an intermediate dataset.
+    #
+    #   DB[:table].select(:name).where_single_value(:id=>1)
+    #   # SELECT name FROM table WHERE (id = 1) LIMIT 1
+    def where_single_value(cond)
+      if loader = cached_placeholder_literalizer(:_where_single_value_loader) do |pl|
+          single_value_ds.where(pl.arg)
+        end
+
+        loader.get(filter_expr(cond))
+      else
+        where(cond).single_value
+      end
+    end
+
     # Run the given SQL and return an array of all rows.  If a block is given,
     # each row is yielded to the block after all rows are loaded. See with_sql_each.
     def with_sql_all(sql, &block)
@@ -1036,6 +1091,13 @@ module Sequel
       cached_dataset(:_single_record_ds){clone(:limit=>1)}
     end
 
+    # Loader used for where_all and where_each.
+    def _where_loader
+      cached_placeholder_literalizer(:_where_loader) do |pl|
+        where(pl.arg)
+      end
+    end
+
     # Automatically alias the given expression if it does not have an identifiable alias.
     def auto_alias_expression(v)
       case v

data/lib/sequel/dataset/dataset_module.rb

@@ -0,0 +1,58 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Dataset
+    # This Module subclass is used by Database#extend_datasets
+    # and Dataset#with_extend to add dataset methods to classes.
+    # It adds some helper methods inside the module that can define
+    # named methods on the dataset instances which do specific actions.
+    # For example:
+    #
+    #   DB.extend_datasets do
+    #     order :by_id, :id
+    #     select :with_id_and_name, :id, :name
+    #     where :active, :active
+    #   end
+    #
+    #   DB[:table].active.with_id_and_name.by_id
+    #   # SELECT id, name FROM table WHERE active ORDER BY id
+    class DatasetModule < ::Module
+      %w'where exclude exclude_having having'.map(&:to_sym).each do |meth|
+        define_method(meth) do |name, *args, &block|
+          if block || args.flatten.any?{|arg| arg.is_a?(Proc)}
+            define_method(name){send(meth, *args, &block)}
+          else
+            key = :"_#{meth}_#{name}_ds"
+            define_method(name) do
+              cached_dataset(key){send(meth, *args)}
+            end
+          end
+        end
+      end
+
+      meths = (<<-METHS).split.map(&:to_sym)
+        distinct grep group group_and_count group_append 
+        limit offset order order_append order_prepend 
+        select select_all select_append select_group server
+      METHS
+
+      # Define a method in the module
+      def self.def_dataset_caching_method(mod, meth)
+        mod.send(:define_method, meth) do |name, *args, &block|
+          if block
+            define_method(name){send(meth, *args, &block)}
+          else
+            key = :"_#{meth}_#{name}_ds"
+            define_method(name) do
+              cached_dataset(key){send(meth, *args)}
+            end
+          end
+        end
+      end
+
+      meths.each do |meth|
+        def_dataset_caching_method(self, meth)
+      end
+    end
+  end
+end

data/lib/sequel/dataset/graph.rb

@@ -275,7 +275,7 @@ module Sequel
     # a select method, and the second is a new hash of preprocessed graph aliases.
     def graph_alias_columns(graph_aliases)
       gas = {}
-      identifiers = graph_aliases.collect do |col_alias, tc| 
+      identifiers = graph_aliases.map do |col_alias, tc| 
         table, column, value = Array(tc)
         column ||= col_alias
         gas[col_alias] = [table, column].freeze

data/lib/sequel/dataset/misc.rb

@@ -35,6 +35,7 @@ module Sequel
       @db = db
       @opts = {} # OPTS # SEQUEL5
       @cache = {}
+      # freeze # SEQUEL5
     end
 
     # Define a hash value such that datasets with the same class, DB, and opts

data/lib/sequel/dataset/prepared_statements.rb

@@ -41,7 +41,7 @@ module Sequel
       meths.each do |meth|
         mod.send(:define_method, :"#{meth}=") do |v|
           # :nocov:
-          Sequel::Deprecation.deprecate("Dataset##{meth}=", "The API has changed, and this value should now be passed in as an option via Dataset#clone.")
+          Sequel::Deprecation.deprecate("Dataset##{meth}=", "The API has changed, and this value should now be passed in as an option via Dataset#clone")
           @opts[meth] = v
           # :nocov:
         end
@@ -214,7 +214,7 @@ module Sequel
           fetch_rows(prepared_sql){|r| return r.values.first}
         when Array
           case prepared_type[0]
-          when :map, :to_hash, :to_hash_groups
+          when :map, :as_hash, :to_hash, :to_hash_groups
             send(*prepared_type, &block) 
           end
         else
@@ -341,7 +341,7 @@ module Sequel
       else
         # :nocov:
         # SEQUEL5: Add coverage
-        Sequel::Deprecation.deprecate("Dataset#prepare will change to requiring a name argument in Sequel 5, please update your code.") unless name
+        Sequel::Deprecation.deprecate("Dataset#prepare will change to requiring a name argument in Sequel 5, please update your code") unless name
         # :nocov:
       end
 

data/lib/sequel/dataset/query.rb

@@ -20,7 +20,7 @@ module Sequel
 
     # Which options don't affect the SQL generation.  Used by simple_select_all?
     # to determine if this is a simple SELECT * FROM table.
-    NON_SQL_OPTIONS = [:server, :graph, :eager, :eager_graph, :graph_aliases, :row_proc, :quote_identifiers, :identifier_input_method, :identifier_output_method, :skip_symbol_cache, :model, :model_object, :association_reflection, :fetch, :numrows, :autoid].freeze # SEQUEL5: Remove graph_aliases
+    NON_SQL_OPTIONS = [:server, :graph, :graph_aliases, :row_proc, :quote_identifiers, :identifier_input_method, :identifier_output_method, :skip_symbol_cache].freeze # SEQUEL5: Remove graph_aliases
     
     # These symbols have _join methods created (e.g. inner_join) that
     # call join_table with the symbol, passing along the arguments and
@@ -44,6 +44,7 @@ module Sequel
       set_graph_aliases unfiltered ungraphed ungrouped union
       unlimited unordered where with with_recursive with_sql
     METHS
+    # SEQUEL5: Remove and, exclude_where
 
     # Register an extension callback for Dataset objects.  ext should be the
     # extension name symbol, and mod should either be a Module that the
@@ -68,6 +69,7 @@ module Sequel
 
     # Alias for where.
     def and(*cond, &block)
+      Sequel::Deprecation.deprecate("Sequel::Dataset#and", "Use #where, or use the sequel_4_dataset_methods extension")
       where(*cond, &block)
     end
     
@@ -190,6 +192,7 @@ module Sequel
 
     # Alias for exclude.
     def exclude_where(*cond, &block)
+      Sequel::Deprecation.deprecate("Sequel::Dataset#exclude_where", "Use #exclude, or use the sequel_4_dataset_methods extension")
       exclude(*cond, &block)
     end
 
@@ -281,8 +284,7 @@ module Sequel
     #   # SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo(c1, c2)
     def from_self(opts=OPTS)
       fs = {}
-      non_sql = non_sql_options
-      @opts.keys.each{|k| fs[k] = nil unless non_sql.include?(k)}
+      @opts.keys.each{|k| fs[k] = nil unless non_sql_option?(k)}
       c = clone(fs).from(opts[:alias] ? as(opts[:alias], opts[:column_aliases]) : self)
       if cols = _columns
         c.send(:columns=, cols)
@@ -576,7 +578,7 @@ module Sequel
         last_alias = options[:implicit_qualifier] || @opts[:last_joined_table] || first_source_alias
         qualify_type = options[:qualify]
         if Sequel.condition_specifier?(expr)
-          expr = expr.collect do |k, v|
+          expr = expr.map do |k, v|
             qualify_type = default_join_table_qualification if qualify_type.nil?
             case qualify_type
             when false
@@ -1085,12 +1087,12 @@ module Sequel
       # Return a clone of the dataset extended with the given modules.
       # Note that like Object#extend, when multiple modules are provided
       # as arguments the cloned dataset is extended with the modules in reverse
-      # order.  If a block is provided, a module is created using the block and
+      # order.  If a block is provided, a DatasetModule is created using the block and
       # the clone is extended with that module after any modules given as arguments.
       def with_extend(*mods, &block)
         c = _clone(:freeze=>false)
         c.extend(*mods) unless mods.empty?
-        c.extend(Module.new(&block)) if block
+        c.extend(DatasetModule.new(&block)) if block
         c.freeze if frozen? # SEQUEL5: Remove if frozen?
         c
       end
@@ -1099,7 +1101,7 @@ module Sequel
       def with_extend(*mods, &block) # :nodoc:
         c = clone
         c.extend(*mods) unless mods.empty?
-        c.extend(Module.new(&block)) if block
+        c.extend(DatasetModule.new(&block)) if block
         c
       end
       # :nocov:
@@ -1137,7 +1139,9 @@ module Sequel
     # * single_record (if only one record could be returned)
     # * single_value (if only one record could be returned, and a single column is selected)
     # * map
+    # * as_hash
     # * to_hash
+    # * to_hash_groups
     # * delete (if a DELETE statement)
     # * update (if an UPDATE statement, with no arguments)
     # * insert (if an INSERT statement, with no arguments)
@@ -1169,7 +1173,7 @@ module Sequel
 
     # Return true if the dataset has a non-nil value for any key in opts.
     def options_overlap(opts)
-      !(@opts.collect{|k,v| k unless v.nil?}.compact & opts).empty?
+      !(@opts.map{|k,v| k unless v.nil?}.compact & opts).empty?
     end
 
     # From types allowed to be considered a simple_select_all
@@ -1181,8 +1185,7 @@ module Sequel
     #   SELECT table.* FROM table
     def simple_select_all?
       return false unless (f = @opts[:from]) && f.length == 1
-      non_sql = non_sql_options
-      o = @opts.reject{|k,v| v.nil? || non_sql.include?(k)}
+      o = @opts.reject{|k,v| v.nil? || non_sql_option?(k)}
       from = f.first
       from = from.expression if from.is_a?(SQL::AliasedExpression)
 
@@ -1358,9 +1361,17 @@ module Sequel
       server?(:default)
     end
 
-    # Dataset options that do not affect the generated SQL.
+    # SEQUEL5: Remove
     def non_sql_options
+      # :nocov:
+      Sequel::Deprecation.deprecate("Dataset#non_sql_options (private method)", "Convert the related code to use the non_sql_option? method")
       NON_SQL_OPTIONS
+      # :nocov:
+    end
+
+    # Whether the given option key does not affect the generated SQL.
+    def non_sql_option?(key)
+      NON_SQL_OPTIONS.include?(key)
     end
 
     # Treat the +block+ as a virtual_row block if not +nil+ and

data/lib/sequel/dataset.rb

@@ -42,5 +42,5 @@ module Sequel
     include SQL::StringMethods
   end
   
-  require(%w"query actions features graph prepared_statements misc mutation sql placeholder_literalizer", 'dataset')
+  require(%w"query actions features graph prepared_statements misc mutation sql placeholder_literalizer dataset_module", 'dataset')
 end

data/lib/sequel/exceptions.rb

@@ -7,6 +7,14 @@ module Sequel
     # If this exception wraps an underlying exception, the underlying
     # exception is held here.
     attr_accessor :wrapped_exception
+
+    if RUBY_VERSION >= '2.1'
+      # Returned the wrapped exception if one exists, otherwise use
+      # ruby's default behavior.
+      def cause
+        wrapped_exception || super
+      end
+    end
   end  
     
   (

data/lib/sequel/extensions/_model_pg_row.rb

@@ -5,14 +5,17 @@ module Sequel
     module PgRow
       module DatabaseMethods
         ESCAPE_RE = /("|\\)/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_RE)
         ESCAPE_REPLACEMENT = '\\\\\1'.freeze
+        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_REPLACEMENT)
         COMMA = ','
+        Sequel::Deprecation.deprecate_constant(self, :COMMA)
 
         # Handle Sequel::Model instances in bound variables.
         def bound_variable_arg(arg, conn)
           case arg
           when Sequel::Model
-            "(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA)})"
+            "(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(',')})"
           else
             super
           end
@@ -34,7 +37,7 @@ module Sequel
         def bound_variable_array(arg)
           case arg
           when Sequel::Model
-            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
+            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
           else
             super
           end

data/lib/sequel/extensions/core_extensions.rb

@@ -48,7 +48,10 @@ class Array
   def sql_value_list
     ::Sequel::SQL::ValueList.new(self)
   end
-  alias sql_array sql_value_list
+  def sql_array
+    Sequel::Deprecation.deprecate("Array#sql_array in the core_extensions extension", "Use Array#sql_value_list instead")
+    sql_value_list
+  end
 
   # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching all of the
   # conditions.  Rarely do you need to call this explicitly, as Sequel generally

data/lib/sequel/extensions/current_datetime_timestamp.rb

@@ -32,7 +32,7 @@ module Sequel
       # Return an instance of Sequel.datetime_class that will be literalized
       # as CURRENT_TIMESTAMP.
       def current_datetime
-        MAP.fetch(Sequel.datetime_class).now
+        (Sequel.datetime_class == ::Time ? Time : DateTime).now
       end
 
       private
@@ -56,6 +56,7 @@ module Sequel
 
     # Mapping of Time/DateTime classes to subclasses literalized as CURRENT_TIMESTAMP
     MAP = {::Time=>Time, ::DateTime=>DateTime}
+    Sequel::Deprecation.deprecate_constant(self, :MAP)
   end
 
   Dataset.register_extension(:current_datetime_timestamp, CurrentDateTimeTimestamp::DatasetMethods)

data/lib/sequel/extensions/date_arithmetic.rb

@@ -67,6 +67,7 @@ module Sequel
         ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map(&:freeze)).freeze
         DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s).freeze}).freeze
         FDBSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.chop).freeze}).freeze
+        Sequel::Deprecation.deprecate_constant(self, :FDBSQL_DURATION_UNITS)
 
         # Append the SQL fragment for the DateAdd expression to the SQL query.
         def date_add_sql_append(sql, da)

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -35,7 +35,7 @@
 
 module Sequel
   module DuplicateColumnsHandler
-    CALLER_ARGS = RUBY_VERSION >= '2.0' ? [0,1] : [0]
+    CALLER_ARGS = (RUBY_VERSION >= '2.0' ? [0,1] : [0]).freeze
 
     # Customize handling of duplicate columns for this dataset.
     def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless block_given?; nil), &block)
@@ -43,6 +43,8 @@ module Sequel
       clone(:on_duplicate_columns=>handler||block)
     end
 
+    private
+
     # Override the attr_writer to check for duplicate columns, and call
     # handle_duplicate_columns if necessary.
     def columns=(cols)
@@ -52,8 +54,6 @@ module Sequel
       super
     end
 
-    private
-
     # Invoke the appropriate behavior when duplicate columns are present.
     def handle_duplicate_columns(cols)
       message = "#{caller(*CALLER_ARGS).first}: One or more duplicate columns present in #{cols.inspect}"

data/lib/sequel/extensions/empty_array_ignore_nulls.rb

@@ -2,4 +2,7 @@
 #
 # This only exists for backwards compatibility, as the behavior
 # added by this extension is now the default Sequel behavior. 
+
+Sequel::Deprecation.deprecate("The empty_array_ignore_nulls", "It has been a no-op since 4.25.0")
+
 Sequel::Dataset.register_extension(:empty_array_ignore_nulls){}

data/lib/sequel/extensions/filter_having.rb

@@ -18,6 +18,8 @@
 #
 # Related module: Sequel::FilterHaving
 
+Sequel::Deprecation.deprecate("The filter_having extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
+
 #
 module Sequel
   module FilterHaving

data/lib/sequel/extensions/freeze_datasets.rb

@@ -67,3 +67,5 @@ module Sequel
     register_extension(:freeze_datasets, FreezeDatasets)
   end
 end
+
+# Sequel::Database.register_extension(:freeze_datasets){} # SEQUEL5

data/lib/sequel/extensions/from_block.rb

@@ -29,9 +29,9 @@ module Sequel
         super
       end
     end
-    # SEQUEL5: Make this an empty module, since it will be the default behavior
   end
 
   Database.register_extension(:from_block, Database::FromBlock)
 end
 
+# Sequel::Database.register_extension(:from_block){} # SEQUEL5

data/lib/sequel/extensions/graph_each.rb

@@ -50,10 +50,10 @@ module Sequel
       # the result set
       datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
       # Get just the list of table aliases into a local variable, for speed
-      table_aliases = datasets.collect{|ta,ds| ta}
+      table_aliases = datasets.map{|ta,ds| ta}
       # Get an array of arrays, one for each dataset, with
       # the necessary information about each dataset, for speed
-      datasets = datasets.collect{|ta, ds| [ta, ds, ds.row_proc]}
+      datasets = datasets.map{|ta, ds| [ta, ds, ds.row_proc]}
       # Use the manually set graph aliases, if any, otherwise
       # use the ones automatically created by .graph
       column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases] # SEQUEL5: Remove :graph_aliases support

data/lib/sequel/extensions/hash_aliases.rb

@@ -18,6 +18,8 @@
 #
 # Related module: Sequel::HashAliases
 
+Sequel::Deprecation.deprecate("The hash_aliases extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
+
 #
 module Sequel
   module HashAliases

data/lib/sequel/extensions/identifier_mangling.rb

@@ -34,13 +34,6 @@
 #
 #   DB.extension :identifier_mangling
 #
-# Historically, Sequel supported these methods by default on
-# Databases and Datasets.  Sequel 4 will continue to support
-# the methods for backwards compatibility, by loading this
-# extension automatically for databases unless the
-# <tt>:identifier_mangling=>false</tt> Database option is
-# used.
-#
 # Related modules: Sequel::IdentifierMangling::DatabaseMethods,
 # Sequel::IdentifierMangling::DatasetMethods
 

data/lib/sequel/extensions/meta_def.rb

@@ -9,6 +9,8 @@
 #
 # Related module: Sequel::Metaprogramming
 
+Sequel::Deprecation.deprecate("The meta_def extension", "Replace meta_def usage with define_singleton_method")
+
 #
 module Sequel
   # Contains meta_def method for adding methods to objects via blocks.