sequel 5.48.0 → 5.52.0

data/lib/sequel/adapters/sqlite.rb

@@ -189,26 +189,24 @@ module Sequel
       # Yield an available connection.  Rescue
       # any SQLite3::Exceptions and turn them into DatabaseErrors.
       def _execute(type, sql, opts, &block)
-        begin
-          synchronize(opts[:server]) do |conn|
-            return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
-            log_args = opts[:arguments]
-            args = {}
-            opts.fetch(:arguments, OPTS).each{|k, v| args[k] = prepared_statement_argument(v)}
-            case type
-            when :select
-              log_connection_yield(sql, conn, log_args){conn.query(sql, args, &block)}
-            when :insert
-              log_connection_yield(sql, conn, log_args){conn.execute(sql, args)}
-              conn.last_insert_row_id
-            when :update
-              log_connection_yield(sql, conn, log_args){conn.execute_batch(sql, args)}
-              conn.changes
-            end
+        synchronize(opts[:server]) do |conn|
+          return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
+          log_args = opts[:arguments]
+          args = {}
+          opts.fetch(:arguments, OPTS).each{|k, v| args[k] = prepared_statement_argument(v)}
+          case type
+          when :select
+            log_connection_yield(sql, conn, log_args){conn.query(sql, args, &block)}
+          when :insert
+            log_connection_yield(sql, conn, log_args){conn.execute(sql, args)}
+            conn.last_insert_row_id
+          when :update
+            log_connection_yield(sql, conn, log_args){conn.execute_batch(sql, args)}
+            conn.changes
           end
-        rescue SQLite3::Exception => e
-          raise_error(e)
         end
+      rescue SQLite3::Exception => e
+        raise_error(e)
       end
       
       # The SQLite adapter does not need the pool to convert exceptions.

data/lib/sequel/adapters/tinytds.rb

@@ -75,7 +75,7 @@ module Sequel
                 return r.public_send(m) if m
               end
             end
-            yield(r) if block_given?
+            yield(r) if defined?(yield)
           rescue TinyTds::Error => e
             raise_error(e, :disconnect=>!c.active?)
           ensure

data/lib/sequel/adapters/utils/columns_limit_1.rb

@@ -0,0 +1,22 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Dataset
+    module ColumnsLimit1
+      COLUMNS_CLONE_OPTIONS = {:distinct => nil, :limit => 1, :offset=>nil, :where=>nil, :having=>nil, :order=>nil, :row_proc=>nil, :graph=>nil, :eager_graph=>nil}.freeze
+
+      # Use a limit of 1 instead of a limit of 0 when
+      # getting the columns.
+      def columns!
+        ds = clone(COLUMNS_CLONE_OPTIONS)
+        ds.each{break}
+
+        if cols = ds.cache[:_columns]
+          self.columns = cols
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/sequel/ast_transformer.rb

@@ -80,6 +80,12 @@ module Sequel
         SQL::DelayedEvaluation.new(lambda{|ds| v(o.call(ds))})
       when SQL::Wrapper
         SQL::Wrapper.new(v(o.value))
+      when SQL::Expression
+        if o.respond_to?(:sequel_ast_transform)
+          o.sequel_ast_transform(method(:v))
+        else
+          o
+        end
       else
         o
       end

data/lib/sequel/connection_pool/sharded_single.rb

@@ -55,13 +55,11 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   # Yields the connection to the supplied block for the given server.
   # This method simulates the ConnectionPool#hold API.
   def hold(server=:default)
-    begin
-      server = pick_server(server)
-      yield(@conns[server] ||= make_new(server))
-    rescue Sequel::DatabaseDisconnectError, *@error_classes => e
-      disconnect_server(server) if disconnect_error?(e)
-      raise
-    end
+    server = pick_server(server)
+    yield(@conns[server] ||= make_new(server))
+  rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+    disconnect_server(server) if disconnect_error?(e)
+    raise
   end
   
   # The ShardedSingleConnectionPool always has a maximum size of 1.

data/lib/sequel/connection_pool/single.rb

@@ -24,15 +24,13 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
 
   # Yield the connection to the block.
   def hold(server=nil)
-    begin
-      unless c = @conn.first
-        @conn.replace([c = make_new(:default)])
-      end
-      yield c
-    rescue Sequel::DatabaseDisconnectError, *@error_classes => e
-      disconnect if disconnect_error?(e)
-      raise
+    unless c = @conn.first
+      @conn.replace([c = make_new(:default)])
     end
+    yield c
+  rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+    disconnect if disconnect_error?(e)
+    raise
   end
 
   # The SingleConnectionPool always has a maximum size of 1.

data/lib/sequel/core.rb

@@ -278,11 +278,9 @@ module Sequel
     #
     #   Sequel.string_to_date('2010-09-10') # Date.civil(2010, 09, 10)
     def string_to_date(string)
-      begin
-        Date.parse(string, Sequel.convert_two_digit_years)
-      rescue => e
-        raise convert_exception_class(e, InvalidValue)
-      end
+      Date.parse(string, Sequel.convert_two_digit_years)
+    rescue => e
+      raise convert_exception_class(e, InvalidValue)
     end
 
     # Converts the given +string+ into a +Time+ or +DateTime+ object, depending on the
@@ -290,15 +288,13 @@ module Sequel
     #
     #   Sequel.string_to_datetime('2010-09-10 10:20:30') # Time.local(2010, 09, 10, 10, 20, 30)
     def string_to_datetime(string)
-      begin
-        if datetime_class == DateTime
-          DateTime.parse(string, convert_two_digit_years)
-        else
-          datetime_class.parse(string)
-        end
-      rescue => e
-        raise convert_exception_class(e, InvalidValue)
+      if datetime_class == DateTime
+        DateTime.parse(string, convert_two_digit_years)
+      else
+        datetime_class.parse(string)
       end
+    rescue => e
+      raise convert_exception_class(e, InvalidValue)
     end
 
     # Converts the given +string+ into a <tt>Sequel::SQLTime</tt> object.
@@ -306,11 +302,9 @@ module Sequel
     #   v = Sequel.string_to_time('10:20:30') # Sequel::SQLTime.parse('10:20:30')
     #   DB.literal(v) # => '10:20:30'
     def string_to_time(string)
-      begin
-        SQLTime.parse(string)
-      rescue => e
-        raise convert_exception_class(e, InvalidValue)
-      end
+      SQLTime.parse(string)
+    rescue => e
+      raise convert_exception_class(e, InvalidValue)
     end
 
     # Unless in single threaded mode, protects access to any mutable
@@ -400,6 +394,11 @@ module Sequel
 
     private
 
+    # Return a hash of date information parsed from the given string.
+    def _date_parse(string)
+      Date._parse(string)
+    end
+
     # Helper method that the database adapter class methods that are added to Sequel via
     # metaprogramming use to parse arguments.
     def adapter_method(adapter, *args, &block)

data/lib/sequel/database/connecting.rb

@@ -55,11 +55,11 @@ module Sequel
 
       begin
         db = c.new(opts)
-        if block_given?
+        if defined?(yield)
           return yield(db)
         end
       ensure
-        if block_given?
+        if defined?(yield)
           db.disconnect if db
           Sequel.synchronize{::Sequel::DATABASES.delete(db)}
         end

data/lib/sequel/database/misc.rb

@@ -95,6 +95,8 @@ module Sequel
     # options hash.
     #
     # Accepts the following options:
+    # :before_preconnect :: Callable that runs after extensions from :preconnect_extensions are loaded,
+    #                       but before any connections are created.
     # :cache_schema :: Whether schema should be cached for this Database instance
     # :default_string_column_size :: The default size of string columns, 255 by default.
     # :extensions :: Extensions to load into this Database instance.  Can be a symbol, array of symbols,
@@ -160,6 +162,10 @@ module Sequel
 
         initialize_load_extensions(:preconnect_extensions)
 
+        if before_preconnect = @opts[:before_preconnect]
+          before_preconnect.call(self)
+        end
+
         if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
           concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
           @pool.send(:preconnect, concurrent)

data/lib/sequel/database/query.rb

@@ -236,7 +236,7 @@ module Sequel
       when :date
         Sequel.string_to_date(default)
       when :datetime
-        DateTime.parse(default)
+        Sequel.string_to_datetime(default)
       when :time
         Sequel.string_to_time(default)
       when :decimal

data/lib/sequel/dataset/actions.rb

@@ -19,7 +19,7 @@ module Sequel
     METHS
 
     # The clone options to use when retrieving 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
+    COLUMNS_CLONE_OPTIONS = {:distinct => nil, :limit => 0, :offset=>nil, :where=>nil, :having=>nil, :order=>nil, :row_proc=>nil, :graph=>nil, :eager_graph=>nil}.freeze
 
     # Inserts the given argument into the database.  Returns self so it
     # can be used safely when chaining:
@@ -546,7 +546,7 @@ module Sequel
       unless @opts[:order]
         raise Sequel::Error, "Dataset#paged_each requires the dataset be ordered"
       end
-      unless block_given?
+      unless defined?(yield)
         return enum_for(:paged_each, opts)
       end
 

data/lib/sequel/dataset/query.rb

@@ -508,6 +508,7 @@ module Sequel
     #                            argument.
     #            :implicit_qualifier :: The name to use for qualifying implicit conditions.  By default,
     #                                   the last joined or primary table is used.
+    #            :join_using :: Force the using of JOIN USING, even if +expr+ is not an array of symbols.
     #            :reset_implicit_qualifier :: Can set to false to ignore this join when future joins determine qualifier
     #                                         for implicit conditions.
     #            :qualify :: Can be set to false to not do any implicit qualification.  Can be set
@@ -541,7 +542,7 @@ module Sequel
         return s.join_table(type, ds, expr, options, &block)
       end
 
-      using_join = expr.is_a?(Array) && !expr.empty? && expr.all?{|x| x.is_a?(Symbol)}
+      using_join = options[:join_using] || (expr.is_a?(Array) && !expr.empty? && expr.all?{|x| x.is_a?(Symbol)})
       if using_join && !supports_join_using?
         h = {}
         expr.each{|e| h[e] = e}
@@ -616,7 +617,7 @@ module Sequel
     UNCONDITIONED_JOIN_TYPES.each do |jtype|
       class_eval(<<-END, __FILE__, __LINE__+1)
         def #{jtype}_join(table, opts=Sequel::OPTS)
-          raise(Sequel::Error, '#{jtype}_join does not accept join table blocks') if block_given?
+          raise(Sequel::Error, '#{jtype}_join does not accept join table blocks') if defined?(yield)
           raise(Sequel::Error, '#{jtype}_join 2nd argument should be an options hash, not conditions') unless opts.is_a?(Hash)
           join_table(:#{jtype}, table, nil, opts)
         end
@@ -1059,6 +1060,7 @@ module Sequel
 
     # Add a common table expression (CTE) with the given name and a dataset that defines the CTE.
     # A common table expression acts as an inline view for the query.
+    #
     # Options:
     # :args :: Specify the arguments/columns for the CTE, should be an array of symbols.
     # :recursive :: Specify that this is a recursive CTE
@@ -1079,10 +1081,35 @@ module Sequel
 
     # Add a recursive common table expression (CTE) with the given name, a dataset that
     # defines the nonrecursive part of the CTE, and a dataset that defines the recursive part
-    # of the CTE.  Options:
+    # of the CTE.
+    #
+    # Options:
     # :args :: Specify the arguments/columns for the CTE, should be an array of symbols.
     # :union_all :: Set to false to use UNION instead of UNION ALL combining the nonrecursive and recursive parts.
     #
+    # PostgreSQL 14+ Options:
+    # :cycle :: Stop recursive searching when a cycle is detected. Includes two columns in the
+    #           result of the CTE, a cycle column indicating whether a cycle was detected for
+    #           the current row, and a path column for the path traversed to get to the current
+    #           row.  If given, must be a hash with the following keys:
+    #           :columns :: (required) The column or array of columns to use to detect a cycle.
+    #                       If the value of these columns match columns already traversed, then
+    #                       a cycle is detected, and recursive searching will not traverse beyond
+    #                       the cycle (the CTE will include the row where the cycle was detected).
+    #           :cycle_column :: The name of the cycle column in the output, defaults to :is_cycle.
+    #           :cycle_value :: The value of the cycle column in the output if the current row was
+    #                           detected as a cycle, defaults to true.
+    #           :noncycle_value :: The value of the cycle column in the output if the current row
+    #                              was not detected as a cycle, defaults to false. Only respected
+    #                              if :cycle_value is given.
+    #           :path_column :: The name of the path column in the output, defaults to :path.
+    # :search :: Include an order column in the result of the CTE that allows for breadth or
+    #            depth first searching. If given, must be a hash with the following keys:
+    #            :by :: (required) The column or array of columns to search by.
+    #            :order_column :: The name of the order column in the output, defaults to :ordercol.
+    #            :type :: Set to :breadth to use breadth-first searching (depth-first searching
+    #                     is the default).
+    #
     #   DB[:t].with_recursive(:t,
     #     DB[:i1].select(:id, :parent_id).where(parent_id: nil),
     #     DB[:i1].join(:t, id: :parent_id).select(Sequel[:i1][:id], Sequel[:i1][:parent_id]),
@@ -1093,6 +1120,21 @@ module Sequel
     #   #   UNION ALL
     #   #   SELECT i1.id, i1.parent_id FROM i1 INNER JOIN t ON (t.id = i1.parent_id)
     #   # ) SELECT * FROM t
+    #
+    #   DB[:t].with_recursive(:t,
+    #     DB[:i1].where(parent_id: nil),
+    #     DB[:i1].join(:t, id: :parent_id).select_all(:i1),
+    #     search: {by: :id, type: :breadth},
+    #     cycle: {columns: :id, cycle_value: 1, noncycle_value: 2})
+    #     
+    #   # WITH RECURSIVE t AS (
+    #   #     SELECT * FROM i1 WHERE (parent_id IS NULL)
+    #   #     UNION ALL
+    #   #     (SELECT i1.* FROM i1 INNER JOIN t ON (t.id = i1.parent_id))
+    #   #   )
+    #   #   SEARCH BREADTH FIRST BY id SET ordercol
+    #   #   CYCLE id SET is_cycle TO 1 DEFAULT 2 USING path
+    #   # SELECT * FROM t
     def with_recursive(name, nonrecursive, recursive, opts=OPTS)
       raise(Error, 'This dataset does not support common table expressions') unless supports_cte?
       if hoist_cte?(nonrecursive)

data/lib/sequel/dataset/sql.rb

@@ -559,11 +559,9 @@ module Sequel
     # Append literalization of JOIN USING clause to SQL string.
     def join_using_clause_sql_append(sql, jc)
       join_clause_sql_append(sql, jc)
-      sql << ' USING ('
-      column_list_append(sql, jc.using)
-      sql << ')'
+      join_using_clause_using_sql_append(sql, jc.using) 
     end
-    
+
     # Append literalization of negative boolean constant to SQL string.
     def negative_boolean_constant_sql_append(sql, constant)
       sql << 'NOT '
@@ -1218,6 +1216,13 @@ module Sequel
       "#{join_type.to_s.gsub('_', ' ').upcase} JOIN"
     end
 
+    # Append USING clause for JOIN USING
+    def join_using_clause_using_sql_append(sql, using_columns)
+      sql << ' USING ('
+      column_list_append(sql, using_columns)
+      sql << ')'
+    end
+    
     # Append a literalization of the array to SQL string.
     # Treats as an expression if an array of all two pairs, or as a SQL array otherwise.
     def literal_array_append(sql, v)
@@ -1538,15 +1543,14 @@ module Sequel
 
     def select_with_sql(sql)
       return unless supports_cte?
-      ws = opts[:with]
-      return if !ws || ws.empty?
+      ctes = opts[:with]
+      return if !ctes || ctes.empty?
       sql << select_with_sql_base
       c = false
       comma = ', '
-      ws.each do |w|
+      ctes.each do |cte|
         sql << comma if c
-        select_with_sql_prefix(sql, w)
-        literal_dataset_append(sql, w[:dataset])
+        select_with_sql_cte(sql, cte)
         c ||= true
       end
       sql << ' '
@@ -1559,6 +1563,11 @@ module Sequel
       "WITH "
     end
 
+    def select_with_sql_cte(sql, cte)
+      select_with_sql_prefix(sql, cte)
+      literal_dataset_append(sql, cte[:dataset])
+    end
+    
     def select_with_sql_prefix(sql, w)
       quote_identifier_append(sql, w[:name])
       if args = w[:args]

data/lib/sequel/extensions/any_not_empty.rb

@@ -33,7 +33,7 @@ module Sequel
   module AnyNotEmpty
     # If a block is not given, return whether the dataset is not empty.
     def any?
-      if block_given?
+      if defined?(yield)
         super
       else
         !empty?

data/lib/sequel/extensions/core_refinements.rb

@@ -15,6 +15,12 @@ raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VE
 # :nocov:
 
 module Sequel::CoreRefinements
+  # :nocov:
+  include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include
+  # :nocov:
+  INCLUDE_METH = include_meth
+  private_constant :INCLUDE_METH
+
   refine Array do
     # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, not matching all of the
     # conditions.
@@ -161,8 +167,8 @@ module Sequel::CoreRefinements
   end
 
   refine String do
-    include Sequel::SQL::AliasMethods
-    include Sequel::SQL::CastMethods
+    send include_meth, Sequel::SQL::AliasMethods
+    send include_meth, Sequel::SQL::CastMethods
 
     # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
     # literalization, e.g.:
@@ -189,15 +195,34 @@ module Sequel::CoreRefinements
   end
 
   refine Symbol do
-    include Sequel::SQL::AliasMethods
-    include Sequel::SQL::CastMethods
-    include Sequel::SQL::OrderMethods
-    include Sequel::SQL::BooleanMethods
-    include Sequel::SQL::NumericMethods
-    include Sequel::SQL::QualifyingMethods
-    include Sequel::SQL::StringMethods
-    include Sequel::SQL::SubscriptMethods
-    include Sequel::SQL::ComplexExpressionMethods
+    send include_meth, Sequel::SQL::AliasMethods
+    send include_meth, Sequel::SQL::CastMethods
+    send include_meth, Sequel::SQL::OrderMethods
+    send include_meth, Sequel::SQL::BooleanMethods
+    send include_meth, Sequel::SQL::NumericMethods
+
+    # :nocov:
+    remove_method :* if RUBY_VERSION >= '3.1'
+    # :nocov:
+
+    send include_meth, Sequel::SQL::QualifyingMethods
+    send include_meth, Sequel::SQL::StringMethods
+    send include_meth, Sequel::SQL::SubscriptMethods
+    send include_meth, Sequel::SQL::ComplexExpressionMethods
+
+    # :nocov:
+    if RUBY_VERSION >= '3.1'
+      remove_method :*
+      def *(ce=(arg=false;nil))
+        if arg == false
+          Sequel::SQL::ColumnAll.new(self)
+        else
+          Sequel::SQL::NumericExpression.new(:*, self, ce)
+        end
+      end
+
+    end
+    # :nocov:
 
     # Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.
     #

data/lib/sequel/extensions/date_parse_input_handler.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+#
+# The date_parse_input_handler extension allows for configuring how input
+# to date parsing methods should be handled.  By default, the
+# extension does not change behavior.  However, you can use the
+# +Sequel.date_parse_input_handler+ method to support custom handling
+# of input strings to the date parsing methods.  For example, if you want
+# to implement a length check to prevent denial of service vulnerabilities
+# in older versions of Ruby, you can do:
+#
+#   Sequel.extension :date_parse_input_handler
+#   Sequel.date_parse_input_handler do |string|
+#     raise Sequel::InvalidValue, "string length (200) exceeds the limit 128" if string.bytesize > 128
+#     string
+#   end
+#
+# You can also use +Sequel.date_parse_input_handler+ to modify the string
+# that will be passed to the parsing methods.  For example, you could
+# truncate it:
+#
+#   Sequel.date_parse_input_handler do |string|
+#     string.b[0, 128]
+#   end
+#
+# Be aware that modern versions of Ruby will raise an exception if
+# date parsing input exceeds 128 bytes.
+
+module Sequel
+  module DateParseInputHandler
+    def date_parse_input_handler(&block)
+      singleton_class.class_eval do
+        define_method(:handle_date_parse_input, &block)
+        private :handle_date_parse_input
+        alias handle_date_parse_input handle_date_parse_input
+      end
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_date(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_datetime(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_time(string)
+      super(handle_date_parse_input(string))
+    end
+
+    private
+
+    # Call date parse input handler with input string.
+    def _date_parse(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Return string as-is by default, so by default behavior does not change.
+    def handle_date_parse_input(string)
+      string
+    end
+  end
+
+  extend DateParseInputHandler
+end

data/lib/sequel/extensions/datetime_parse_to_time.rb

@@ -19,7 +19,11 @@ module Sequel::DateTimeParseToTime
   # Use DateTime.parse.to_time to do the conversion if the input a string and is assumed to
   # be in UTC and there is no offset information in the string.
   def convert_input_timestamp(v, input_timezone)
-    if v.is_a?(String) && datetime_class == Time && input_timezone == :utc && !Date._parse(v).has_key?(:offset)
+    if v.is_a?(String) && datetime_class == Time && input_timezone == :utc && !_date_parse(v).has_key?(:offset)
+      # :nocov:
+      # Whether this is fully branch covered depends on the order in which the specs are run.
+      v = handle_date_parse_input(v) if respond_to?(:handle_date_parse_input, true)
+      # :nocov:
       t = DateTime.parse(v).to_time
       case application_timezone
       when nil, :local

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -44,7 +44,7 @@ module Sequel
     # :nocov:
 
     # 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)
+    def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless defined?(yield); nil), &block)
       raise Error, "Cannot provide both an argument and a block to on_duplicate_columns" if handler && block
       clone(:on_duplicate_columns=>handler||block)
     end

data/lib/sequel/extensions/inflector.rb

@@ -102,7 +102,7 @@ class String
   # Yield the Inflections module if a block is given, and return
   # the Inflections module.
   def self.inflections
-    yield Inflections if block_given?
+    yield Inflections if defined?(yield)
     Inflections
   end
   

data/lib/sequel/extensions/migration.rb

@@ -388,6 +388,9 @@ module Sequel
 
     # Migrates the supplied database using the migration files in the specified directory. Options:
     # :allow_missing_migration_files :: Don't raise an error if there are missing migration files.
+    #                                   It is very risky to use this option, since it can result in
+    #                                   the database schema version number not matching the expected
+    #                                   database schema.
     # :column :: The column in the :table argument storing the migration version (default: :version).
     # :current :: The current version of the database.  If not given, it is retrieved from the database
     #             using the :table and :column options.
@@ -542,7 +545,7 @@ module Sequel
 
       @direction = current < target ? :up : :down
 
-      if @direction == :down && @current >= @files.length
+      if @direction == :down && @current >= @files.length && !@allow_missing_migration_files
         raise Migrator::Error, "Missing migration version(s) needed to migrate down to target version (current: #{current}, target: #{target})"
       end
 

data/lib/sequel/extensions/pagination.rb

@@ -54,7 +54,7 @@ module Sequel
     # an enumerator if no block is given.
     def each_page(page_size)
       raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
-      return to_enum(:each_page, page_size) unless block_given?
+      return to_enum(:each_page, page_size) unless defined?(yield)
       record_count = count
       total_pages = (record_count / page_size.to_f).ceil
       (1..total_pages).each{|page_no| yield paginate(page_no, page_size, record_count)}

data/lib/sequel/extensions/pg_array_ops.rb

@@ -329,7 +329,7 @@ end
 if defined?(Sequel::CoreRefinements)
   module Sequel::CoreRefinements
     refine Symbol do
-      include Sequel::Postgres::ArrayOpMethods
+      send INCLUDE_METH, Sequel::Postgres::ArrayOpMethods
     end
   end
 end

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -83,7 +83,7 @@ module Sequel
       # If convert_infinite_timestamps is true and the value is infinite, return an appropriate
       # value based on the convert_infinite_timestamps setting.
       def to_application_timestamp(value)
-        if value.is_a?(String) && (m = value.match(/((?:[-+]\d\d:\d\d)(:\d\d)?)?( BC)?\z/)) && (m[2] || m[3])
+        if value.is_a?(String) && (m = /((?:[-+]\d\d:\d\d)(:\d\d)?)?( BC)?\z/.match(value)) && (m[2] || m[3])
           if m[3]
             value = value.sub(' BC', '').sub(' ', ' BC ')
             conv = defined?(JRUBY_VERSION) && JRUBY_VERSION == '9.2.0.0'