sequel 5.39.0 → 5.63.0

data/lib/sequel/extensions/date_arithmetic.rb

@@ -8,9 +8,10 @@
 #   DB.extension :date_arithmetic
 #
 # Then you can use the Sequel.date_add and Sequel.date_sub methods
-# to return Sequel expressions:
+# to return Sequel expressions (this example shows the only supported
+# keys for the second argument):
 #
-#   add = Sequel.date_add(:date_column, years: 1, months: 2, days: 3)
+#   add = Sequel.date_add(:date_column, years: 1, months: 2, weeks: 2, days: 1)
 #   sub = Sequel.date_sub(:date_column, hours: 1, minutes: 2, seconds: 3)
 #
 # In addition to specifying the interval as a hash, there is also
@@ -24,13 +25,17 @@
 # By default, values are casted to the generic timestamp type for the
 # database.  You can override the cast type using the :cast option:
 #
-#   add = Sequel.date_add(:date_column, {years: 1, months: 2, days: 3}, :cast=>:timestamptz)
+#   add = Sequel.date_add(:date_column, {years: 1, months: 2, days: 3}, cast: :timestamptz)
 #
 # These expressions can be used in your datasets, or anywhere else that
 # Sequel expressions are allowed:
 #
 #   DB[:table].select(add.as(:d)).where(sub > Sequel::CURRENT_TIMESTAMP)
 #
+# On most databases, the values you provide for years/months/days/etc. must
+# be numeric values and not arbitrary SQL expressions.  However, on PostgreSQL
+# 9.4+, use of arbitrary SQL expressions is supported.
+#
 # Related module: Sequel::SQL::DateAdd
 
 #
@@ -49,14 +54,21 @@ module Sequel
       # Options:
       # :cast :: Cast to the specified type instead of the default if casting
       def date_sub(expr, interval, opts=OPTS)
-        interval = if interval.is_a?(Hash)
-          h = {}
-          interval.each{|k,v| h[k] = -v unless v.nil?}
-          h
-        else
-          -interval
+        if defined?(ActiveSupport::Duration) && interval.is_a?(ActiveSupport::Duration)
+          interval = interval.parts
         end
-        DateAdd.new(expr, interval, opts)
+        parts = {}
+        interval.each do |k,v|
+          case v
+          when nil
+            # ignore
+          when Numeric
+            parts[k] = -v
+          else
+            parts[k] = Sequel::SQL::NumericExpression.new(:*, v, -1)
+          end
+        end
+        DateAdd.new(expr, parts, opts)
       end
     end
 
@@ -69,6 +81,7 @@ module Sequel
       module DatasetMethods
         DURATION_UNITS = [:years, :months, :days, :hours, :minutes, :seconds].freeze
         DEF_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s.freeze}).freeze
+        POSTGRES_DURATION_UNITS = DURATION_UNITS.zip([:years, :months, :days, :hours, :mins, :secs].map{|s| s.to_s.freeze}).freeze
         MYSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.upcase[0...-1]).freeze}).freeze
         MSSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s[0...-1]).freeze}).freeze
         H2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s[0...-1].freeze}).freeze
@@ -88,14 +101,28 @@ module Sequel
 
           cast = case db_type = db.database_type
           when :postgres
-            interval = String.new
-            each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
-              interval << "#{value} #{sql_unit} "
+            casted = Sequel.cast(expr, cast_type)
+
+            if db.server_version >= 90400
+              placeholder = []
+              vals = []
+              each_valid_interval_unit(h, POSTGRES_DURATION_UNITS) do |value, sql_unit|
+                placeholder << "#{', ' unless placeholder.empty?}#{sql_unit} := "
+                vals << value
+              end
+              interval = Sequel.function(:make_interval, Sequel.lit(placeholder, *vals)) unless vals.empty?
+            else
+              parts = String.new
+              each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
+                parts << "#{value} #{sql_unit} "
+              end
+              interval = Sequel.cast(parts, :interval) unless parts.empty?
             end
-            if interval.empty?
-              return literal_append(sql, Sequel.cast(expr, cast_type))
+
+            if interval
+              return complex_expression_sql_append(sql, :+, [casted, interval])
             else
-              return complex_expression_sql_append(sql, :+, [Sequel.cast(expr, cast_type), Sequel.cast(interval, :interval)])
+              return literal_append(sql, casted)
             end
           when :sqlite
             args = [expr]
@@ -113,12 +140,12 @@ module Sequel
             end
           when :mssql, :h2, :access, :sqlanywhere
             units = case db_type
-            when :mssql, :sqlanywhere
-              MSSQL_DURATION_UNITS
             when :h2
               H2_DURATION_UNITS
             when :access
               ACCESS_DURATION_UNITS
+            else
+              MSSQL_DURATION_UNITS
             end
             each_valid_interval_unit(h, units) do |value, sql_unit|
               expr = Sequel.function(:DATEADD, sql_unit, value, expr)
@@ -186,22 +213,35 @@ module Sequel
       # ActiveSupport::Duration :: Converted to a hash using the interval's parts.
       def initialize(expr, interval, opts=OPTS)
         @expr = expr
-        @interval = if interval.is_a?(Hash)
-          interval.each_value do |v|
-             # Attempt to prevent SQL injection by users who pass untrusted strings
-             # as interval values. 
-             if v.is_a?(String) && !v.is_a?(LiteralString)
-               raise Sequel::InvalidValue, "cannot provide String value as interval part: #{v.inspect}"
-             end
+
+        h = Hash.new(0)
+        interval = interval.parts unless interval.is_a?(Hash)
+        interval.each do |unit, value|
+          # skip nil values
+          next unless value
+
+          # Convert weeks to days, as ActiveSupport::Duration can use weeks,
+          # but the database-specific literalizers only support days.
+          if unit == :weeks
+            unit = :days
+            value *= 7
+          end
+
+          unless DatasetMethods::DURATION_UNITS.include?(unit)
+            raise Sequel::Error, "Invalid key used in DateAdd interval hash: #{unit.inspect}"
+          end
+
+          # Attempt to prevent SQL injection by users who pass untrusted strings
+          # as interval values. It doesn't make sense to support literal strings,
+          # due to the numeric adding below.
+          if value.is_a?(String)
+            raise Sequel::InvalidValue, "cannot provide String value as interval part: #{value.inspect}"
           end
-          Hash[interval]
-        else
-          h = Hash.new(0)
-          interval.parts.each{|unit, value| h[unit] += value}
-          Hash[h]
+
+          h[unit] += value
         end
 
-        @interval.freeze
+        @interval = Hash[h].freeze
         @cast_type = opts[:cast] if opts[:cast]
         freeze
       end

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/eval_inspect.rb

@@ -55,6 +55,8 @@ module Sequel
 
   module SQL
     class Expression
+      alias inspect inspect
+
       # Attempt to produce a string suitable for eval, such that:
       #
       #   eval(obj.inspect) == obj

data/lib/sequel/extensions/inflector.rb

@@ -102,9 +102,17 @@ 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
+  
+  %w'classify constantize dasherize demodulize foreign_key humanize pluralize singularize tableize underscore'.each do |m|
+    # :nocov:
+    if method_defined?(m)
+      alias_method(m, m)
+    end
+    # :nocov:
+  end
 
   # By default, camelize converts the string to UpperCamelCase. If the argument to camelize
   # is set to :lower then camelize produces lowerCamelCase.

data/lib/sequel/extensions/is_distinct_from.rb

@@ -0,0 +1,141 @@
+# frozen-string-literal: true
+#
+# The is_distinct_from extension adds the ability to use the
+# SQL standard IS DISTINCT FROM operator, which is similar to the
+# not equals operator, except that NULL values are considered
+# equal.  PostgreSQL, SQLite 3.39+, and H2 currently support this operator.  On 
+# other databases, support is emulated.
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :is_distinct_from
+#
+# Then you can use the Sequel.is_distinct_from to create the expression
+# objects:  
+#
+#   expr = Sequel.is_distinct_from(:column_a, :column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#
+# You can also use the +is_distinct_from+ method on most Sequel expressions:
+#
+#   expr = Sequel[:column_a].is_distinct_from(:column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#   
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].where(expr)
+#
+# Related module: Sequel::SQL::IsDistinctFrom
+
+#
+module Sequel
+  module SQL
+    module Builders
+      # Return a IsDistinctFrom expression object, using the IS DISTINCT FROM operator
+      # with the given left hand side and right hand side.
+      def is_distinct_from(lhs, rhs)
+        BooleanExpression.new(:NOOP, IsDistinctFrom.new(lhs, rhs))
+      end
+    end
+
+    # Represents an SQL expression using the IS DISTINCT FROM operator.
+    class IsDistinctFrom < GenericExpression
+      # These methods are added to expressions, allowing them to return IS DISTINCT
+      # FROM expressions based on the receiving expression.
+      module Methods
+        # Return a IsDistinctFrom expression, using the IS DISTINCT FROM operator,
+        # with the receiver as the left hand side and the argument as the right hand side.
+        def is_distinct_from(rhs)
+          BooleanExpression.new(:NOOP, IsDistinctFrom.new(self, rhs))
+        end
+      end
+
+      # These methods are added to datasets using the is_distinct_from extension
+      # extension, for the purposes of correctly literalizing IsDistinctFrom
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        # Append the SQL fragment for the IS DISTINCT FROM expression to the SQL query.
+        def is_distinct_from_sql_append(sql, idf)
+          lhs = idf.lhs
+          rhs = idf.rhs
+
+          if supports_is_distinct_from?
+            sql << "("
+            literal_append(sql, lhs)
+            sql << " IS DISTINCT FROM "
+            literal_append(sql, rhs)
+            sql << ")"
+          elsif db.database_type == :derby && (lhs == nil || rhs == nil)
+            if lhs == nil && rhs == nil
+              sql << literal_false
+            elsif lhs == nil
+              literal_append(sql, ~Sequel.expr(rhs=>nil))
+            else
+              literal_append(sql, ~Sequel.expr(lhs=>nil))
+            end
+          else
+            literal_append(sql, Sequel.case({(Sequel.expr(lhs=>rhs) | [[lhs, nil], [rhs, nil]]) => 0}, 1) => 1)
+          end
+        end
+
+        private
+
+        # Whether the database supports IS DISTINCT FROM.
+        def supports_is_distinct_from?
+          if defined?(super)
+            return super
+          end
+        
+          case db.database_type
+          when :postgres, :h2
+            true
+          when :sqlite
+            db.sqlite_version >= 33900
+          else
+            false
+          end
+        end
+      end
+
+      # The left hand side of the IS DISTINCT FROM expression.
+      attr_reader :lhs
+
+      # The right hand side of the IS DISTINCT FROM expression.
+      attr_reader :rhs
+
+      def initialize(lhs, rhs)
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      to_s_method :is_distinct_from_sql
+    end
+  end
+
+  class SQL::GenericExpression
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  class LiteralString
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  Dataset.register_extension(:is_distinct_from, SQL::IsDistinctFrom::DatasetMethods)
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::SQL::IsDistinctFrom::Methods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      send INCLUDE_METH, Sequel::SQL::IsDistinctFrom::Methods
+    end
+  end
+end
+# :nocov:

data/lib/sequel/extensions/looser_typecasting.rb

@@ -8,6 +8,9 @@
 # :decimal :: use 0.0 for unsupported strings
 # :string :: silently allow hash and array conversion to string
 #
+# This also removes bytesize checks for string inputs for float, integer
+# and decimal conversions.
+#
 # To load the extension into the database:
 #
 #   DB.extension :looser_typecasting

data/lib/sequel/extensions/migration.rb

@@ -68,7 +68,9 @@ module Sequel
       # Allow calling private methods for backwards compatibility
       @db.send(method_sym, *args, &block)
     end
+    # :nocov:
     ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    # :nocov:
 
     # This object responds to all methods the database responds to.
     def respond_to_missing?(meth, include_private)
@@ -375,7 +377,7 @@ module Sequel
     # Raise a NotCurrentError unless the migrator is current, takes the same
     # arguments as #run.
     def self.check_current(*args)
-      raise(NotCurrentError, 'migrator is not current') unless is_current?(*args)
+      raise(NotCurrentError, 'current migration version does not match latest available version') unless is_current?(*args)
     end
 
     # Return whether the migrator is current (i.e. it does not need to make
@@ -386,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.
@@ -540,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/named_timezones.rb

@@ -68,6 +68,10 @@ module Sequel
     private 
     
     if RUBY_VERSION >= '2.6'
+      # Whether Time.at with :nsec and :in is broken.  True on JRuby < 9.3.9.0.
+      BROKEN_TIME_AT_WITH_NSEC = defined?(JRUBY_VERSION) && (JRUBY_VERSION < '9.3' || (JRUBY_VERSION < '9.4' && JRUBY_VERSION.split('.')[2].to_i < 9))
+      private_constant :BROKEN_TIME_AT_WITH_NSEC
+
       # Convert the given input Time (which must be in UTC) to the given input timezone,
       # which should be a TZInfo::Timezone instance.
       def convert_input_time_other(v, input_timezone)
@@ -76,35 +80,49 @@ module Sequel
         raise unless disamb = tzinfo_disambiguator_for(v)
         period = input_timezone.period_for_local(v, &disamb)
         offset = period.utc_total_offset
-        Time.at(v.to_i - offset, :in => input_timezone)
+        # :nocov:
+        if BROKEN_TIME_AT_WITH_NSEC
+          Time.at(v.to_i - offset, :in => input_timezone) + v.nsec/1000000000.0
+        # :nocov:
+        else
+          Time.at(v.to_i - offset, v.nsec, :nsec, :in => input_timezone)
+        end
       end
 
       # Convert the given input Time to the given output timezone,
       # which should be a TZInfo::Timezone instance.
       def convert_output_time_other(v, output_timezone)
-        Time.at(v.to_i, :in => output_timezone)
+        # :nocov:
+        if BROKEN_TIME_AT_WITH_NSEC
+          Time.at(v.to_i, :in => output_timezone) + v.nsec/1000000000.0
+        # :nocov:
+        else
+          Time.at(v.to_i, v.nsec, :nsec, :in => output_timezone)
+        end
       end
-    else
       # :nodoc:
       # :nocov:
+    else
       def convert_input_time_other(v, input_timezone)
         local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
-        Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+        Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + v.nsec/1000000000.0 
       end
 
       if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
         def convert_output_time_other(v, output_timezone)
           v = output_timezone.utc_to_local(v.getutc)
           local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
-          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + local_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + v.nsec/1000000000.0 + local_offset
         end
       else
         def convert_output_time_other(v, output_timezone)
           v = output_timezone.utc_to_local(v.getutc)
           local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
-          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + v.nsec/1000000000.0
         end
       end
+      # :nodoc:
+      # :nocov:
     end
 
     # Handle both TZInfo 1 and TZInfo 2
@@ -142,6 +160,8 @@ module Sequel
         # Convert timezone offset from UTC to the offset for the output_timezone
         (v - local_offset).new_offset(local_offset)
       end
+      # :nodoc:
+      # :nocov:
     end
     
     # Returns TZInfo::Timezone instance if given a String.

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.rb

@@ -213,6 +213,7 @@ module Sequel
             scalar_typecast_method = :"typecast_value_#{opts.fetch(:scalar_typecast, type)}"
             define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
             private meth
+            alias_method(meth, meth)
           end
 
           @schema_type_classes[:"#{type}_array"] = PGArray
@@ -227,16 +228,27 @@ module Sequel
           when Array
             "{#{a.map{|i| bound_variable_array(i)}.join(',')}}"
           when Sequel::SQL::Blob
-            "\"#{literal(a)[BLOB_RANGE].gsub("''", "'").gsub(/("|\\)/, '\\\\\1')}\""
+            bound_variable_array_string(literal(a)[BLOB_RANGE].gsub("''", "'"))
           when Sequel::LiteralString
             a
           when String
-            "\"#{a.gsub(/("|\\)/, '\\\\\1')}\""
+            bound_variable_array_string(a)
           else
-            literal(a)
+            if (s = bound_variable_arg(a, nil)).is_a?(String)
+              bound_variable_array_string(s)
+            else
+              literal(a)
+            end
           end
         end
 
+        # Escape strings used as array members in bound variables. Most complex
+        # will create a regular string with bound_variable_arg, and then use this
+        # escaping to format it as an array member.
+        def bound_variable_array_string(s)
+          "\"#{s.gsub(/("|\\)/, '\\\\\1')}\""
+        end
+
         # Look into both the current database's array schema types and the global
         # array schema types to get the type symbol for the given database type
         # string.
@@ -456,6 +468,14 @@ module Sequel
         end
       end
 
+      # Allow automatic parameterization of the receiver if all elements can be
+      # can be automatically parameterized.
+      def sequel_auto_param_type(ds)
+        if array_type && all?{|x| nil == x || ds.send(:auto_param_type, x)}
+          "::#{array_type}[]"
+        end
+      end
+
       private
 
       # Recursive method that handles multi-dimensional

data/lib/sequel/extensions/pg_array_ops.rb

@@ -108,7 +108,7 @@ module Sequel
 
       # Call the ANY function:
       #
-      #   array_op.all # ANY(array)
+      #   array_op.any # ANY(array)
       #
       # Usually used like:
       #
@@ -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