sequel 5.60.0 → 5.61.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bd9076a491b881827f095bbb1177974861448054cd73376ee76a42ed0f72ee5
-  data.tar.gz: e2e23f283d2d9f5b29df1510f5f39c8335cc47c37d0f92c848763cd437d4e668
+  metadata.gz: f542d5f0e7cca642a8fccd52cb4099101f38dbd1617ff2437b8690766b5f2bdd
+  data.tar.gz: 79ff2215f1e38e523e7e64a5779bee695a939a03f046a5e2e9a5974a804a714c
 SHA512:
-  metadata.gz: 309b37a25a51bc38c30c20276b7df1df4d21b6b14502b129fc363a0ac9bfc4897be03c21ec1d5b4b333eb6c1944491e4383406bb3f2cb96ba8dd1e98b513de42
-  data.tar.gz: 58adf4e309a3bd1d921f95d168a79830cce4526767b8ee9379ce69463327b10f0db4ded44a4a8e474cd0dd31036546b120f3e38a07c3057a5290933cffd3b77a
+  metadata.gz: 1e0bdc80d388f1bdbf39674624522f7086ca5b0904df2bb28d7b6f3c8f6057df38eca1c0854905a87d920286e578d1e0fe269deb33c3c3f1691d2113a9f23d11
+  data.tar.gz: 31ebb15cc504b82c5406c2f7eb6a02a99aa035e9486ecd52698403eff7bd79a99e606229dbbf392ac3fabd1b68c9a7ebc09c127dea3970e2a083c7d781159f33

data/CHANGELOG

@@ -1,3 +1,19 @@
+=== 5.61.0 (2022-10-01)
+
+* Make Database#foreign_key_list on PostgreSQL return results for partitioned tables (jeremyevans)
+
+* Add Database#check_string_typecast_bytesize for checking bytesize of strings before typecasting (jeremyevans)
+
+* Treat negative hexidecimal strings similar to positive hexidecimal strings when typecasting to integer (jeremyevans)
+
+* Remove is_json and is_not_json methods from the pg_json_ops extension, as the support was removed in PostgreSQL 15 beta 4 (jeremyevans)
+
+* Fix handling of timestamps before the date of calendar reform when using pg_extended_date_support extension on Ruby 3.2 (jeremyevans)
+
+=== 5.60.1 (2022-09-02)
+
+* Revert conversion of respond_to? to defined?, as it breaks with unused refinements on Ruby 2 (jeremyevans) (#1919)
+
 === 5.60.0 (2022-09-01)
 
 * Support arbitrary expressions for date_arithmetic interval values on PostgreSQL 9.4+ (jeremyevans)

data/doc/release_notes/5.61.0.txt

@@ -0,0 +1,43 @@
+= Improvements
+
+* When typecasting strings to other types, Sequel::Database will now
+  by default not typecast strings that are much longer than expected
+  for the underlying type. Depending on the underlying type, there
+  is a limit of either 100 or 1000 bytes on the input string.  This
+  avoids potential performance issues when trying to convert
+  arbitrary sized user input to specific types.
+
+* The respond_to? to defined? change made in 5.60.0 was reverted in
+  5.60.1 as it broke cases on Ruby < 3 where the object had an unused
+  refinement that added the method.
+
+* When typecasting strings to integer, strings such as -0xa are now
+  treated as negative hexidecimal strings, similar to how 0xa is
+  treated as a positive hexidecimal string.
+
+* Database#foreign_key_list now returns results for partitioned
+  tables on PostgreSQL 11+.
+
+* Timestamps before the date of calendar reform are now handled
+  correctly by the pg_extended_date_support extension when using
+  Ruby 3.2 preview 2+.
+
+= Backwards Compatibility
+
+* The change to not typecast strings that are too long can break
+  backwards compatibility for applications that expect typecasting
+  for input beyond Sequel's limits.  You can disable the string
+  bytesize checking by setting:
+
+    DB.check_string_typecast_bytesize = false
+
+  or by passing the check_string_typecast_bytesize: false option when
+  creating the Database instance.
+
+* Code to workaround a bug in JRuby 9.2.0.0 has been removed from the
+  pg_extended_date_support extension.  Users of the extension should
+  upgrade to a newer JRuby version.
+
+* The is_json and is_not_json methods have been removed from the
+  pg_json_ops extension, as the underlying support was removed in
+  PostgreSQL 15 beta 4.

data/lib/sequel/adapters/jdbc/sqlite.rb

@@ -125,7 +125,7 @@ module Sequel
 
         # The result code for the exception, if the jdbc driver supports result codes for exceptions.
         def sqlite_error_code(exception)
-          exception.resultCode.code if defined?(exception.resultCode)
+          exception.resultCode.code if exception.respond_to?(:resultCode)
         end
       end
     end

data/lib/sequel/adapters/jdbc.rb

@@ -38,7 +38,7 @@ module Sequel
     else
       if defined?(::Jdbc) && ( ::Jdbc.const_defined?(name) rescue nil )
         jdbc_module = ::Jdbc.const_get(name) # e.g. Jdbc::SQLite3
-        jdbc_module.load_driver if defined?(jdbc_module.load_driver)
+        jdbc_module.load_driver if jdbc_module.respond_to?(:load_driver)
       end
     end
 
@@ -396,9 +396,9 @@ module Sequel
 
       def database_exception_sqlstate(exception, opts)
         if database_exception_use_sqlstates?
-          while defined?(exception.cause)
+          while exception.respond_to?(:cause)
             exception = exception.cause
-            return exception.getSQLState if defined?(exception.getSQLState)
+            return exception.getSQLState if exception.respond_to?(:getSQLState)
           end
         end
         nil
@@ -415,8 +415,8 @@ module Sequel
 
       # Raise a disconnect error if the SQL state of the cause of the exception indicates so.
       def disconnect_error?(exception, opts)
-        cause = defined?(exception.cause) ? exception.cause : exception
-        super || (defined?(cause.getSQLState) && cause.getSQLState =~ /^08/)
+        cause = exception.respond_to?(:cause) ? exception.cause : exception
+        super || (cause.respond_to?(:getSQLState) && cause.getSQLState =~ /^08/)
       end
 
       # Execute the prepared statement.  If the provided name is a

data/lib/sequel/adapters/mock.rb

@@ -257,7 +257,7 @@ module Sequel
             @shared_adapter = true
             extend(mod::DatabaseMethods)
             extend_datasets(mod::DatasetMethods)
-            if defined?(mod.mock_adapter_setup)
+            if mod.respond_to?(:mock_adapter_setup)
               mod.mock_adapter_setup(self)
             end
           end

data/lib/sequel/adapters/mysql.rb

@@ -72,7 +72,7 @@ module Sequel
       def connect(server)
         opts = server_opts(server)
 
-        if defined?(Mysql.init)
+        if Mysql.respond_to?(:init)
           conn = Mysql.init
           conn.options(Mysql::READ_DEFAULT_GROUP, opts[:config_default_group] || "client")
           conn.options(Mysql::OPT_LOCAL_INFILE, opts[:config_local_infile]) if opts.has_key?(:config_local_infile)
@@ -186,7 +186,7 @@ module Sequel
         elsif defined?(yield)
           yield conn
         end
-        if defined?(conn.more_results?)
+        if conn.respond_to?(:more_results?)
           while conn.more_results? do
             if r
               r.free
@@ -207,7 +207,7 @@ module Sequel
       ensure
         r.free if r
         # Use up all results to avoid a commands out of sync message.
-        if defined?(conn.more_results?)
+        if conn.respond_to?(:more_results?)
           while conn.more_results? do
             begin
               conn.next_result

data/lib/sequel/adapters/oracle.rb

@@ -149,7 +149,7 @@ module Sequel
       end
 
       def database_specific_error_class(exception, opts)
-        return super unless defined?(exception.code)
+        return super unless exception.respond_to?(:code)
         case exception.code
         when 1400, 1407
           NotNullConstraintViolation

data/lib/sequel/adapters/postgres.rb

@@ -160,7 +160,7 @@ module Sequel
         begin
           defined?(yield) ? yield(q) : q.cmd_tuples
         ensure
-          q.clear if q && defined?(q.clear)
+          q.clear if q && q.respond_to?(:clear)
         end
       end
 
@@ -258,7 +258,7 @@ module Sequel
 
         # :nocov:
         if encoding = opts[:encoding] || opts[:charset]
-          if defined?(conn.set_client_encoding)
+          if conn.respond_to?(:set_client_encoding)
             conn.set_client_encoding(encoding)
           else
             conn.async_exec("set client_encoding to '#{encoding}'")
@@ -492,12 +492,12 @@ module Sequel
                 opts[:after_listen].call(conn) if opts[:after_listen]
                 timeout = opts[:timeout]
                 if timeout
-                  timeout_block = defined?(timeout.call) ? timeout : proc{timeout}
+                  timeout_block = timeout.respond_to?(:call) ? timeout : proc{timeout}
                 end
 
                 if l = opts[:loop]
                   raise Error, 'calling #listen with :loop requires a block' unless block
-                  loop_call = defined?(l.call)
+                  loop_call = l.respond_to?(:call)
                   catch(:stop) do
                     while true
                       t = timeout_block ? [timeout_block.call] : []
@@ -582,7 +582,7 @@ module Sequel
 
       def database_exception_sqlstate(exception, opts)
         # :nocov:
-        if defined?(exception.result) && (result = exception.result)
+        if exception.respond_to?(:result) && (result = exception.result)
         # :nocov:
           result.error_field(PGresult::PG_DIAG_SQLSTATE)
         end
@@ -625,7 +625,7 @@ module Sequel
         begin
           defined?(yield) ? yield(q) : q.cmd_tuples
         ensure
-          q.clear if q && defined?(q.clear)
+          q.clear if q && q.respond_to?(:clear)
         end
       end
 

data/lib/sequel/adapters/shared/mssql.rb

@@ -205,7 +205,7 @@ module Sequel
           return @server_version = Integer(@opts[:server_version])
         end
         @server_version = synchronize(server) do |conn|
-          (conn.server_version rescue nil) if defined?(conn.server_version)
+          (conn.server_version rescue nil) if conn.respond_to?(:server_version)
         end
         unless @server_version
           m = /^(\d+)\.(\d+)\.(\d+)/.match(fetch("SELECT CAST(SERVERPROPERTY('ProductVersion') AS varchar)").single_value.to_s)

data/lib/sequel/adapters/shared/oracle.rb

@@ -121,7 +121,7 @@ module Sequel
       def server_version(server=nil)
         return @server_version if @server_version
         @server_version = synchronize(server) do |conn|
-          (conn.server_version rescue nil) if defined?(conn.server_version)
+          (conn.server_version rescue nil) if conn.respond_to?(:server_version)
         end
         unless @server_version
           @server_version = if m = /(\d+)\.(\d+)\.?(\d+)?\.?(\d+)?/.match(fetch("select version from PRODUCT_COMPONENT_VERSION where lower(product) like 'oracle%'").single_value)

data/lib/sequel/adapters/shared/postgres.rb

@@ -586,7 +586,7 @@ module Sequel
           join(Sequel[:pg_namespace].as(:nsp), :oid=>Sequel[:cl2][:relnamespace]).
           order{[co[:conname], cpos]}.
           where{{
-            cl[:relkind]=>'r',
+            cl[:relkind]=>%w'r p',
             co[:contype]=>'f',
             cl[:oid]=>oid,
             cpos=>rpos

data/lib/sequel/adapters/sqlite.rb

@@ -305,7 +305,7 @@ module Sequel
       if USE_EXTENDED_RESULT_CODES
         # Support SQLite exception codes if ruby-sqlite3 supports them.
         def sqlite_error_code(exception)
-          exception.code if defined?(exception.code)
+          exception.code if exception.respond_to?(:code)
         end
       end
     end

data/lib/sequel/ast_transformer.rb

@@ -81,7 +81,7 @@ module Sequel
       when SQL::Wrapper
         SQL::Wrapper.new(v(o.value))
       when SQL::Expression
-        if defined?(o.sequel_ast_transform)
+        if o.respond_to?(:sequel_ast_transform)
           o.sequel_ast_transform(method(:v))
         else
           o

data/lib/sequel/database/misc.rb

@@ -91,6 +91,11 @@ module Sequel
     # The specific default size of string columns for this Sequel::Database, usually 255 by default.
     attr_accessor :default_string_column_size
 
+    # Whether to check the bytesize of strings before typecasting (to avoid typecasting strings that
+    # would be too long for the given type), true by default. Strings that are too long will raise
+    # a typecasting error.
+    attr_accessor :check_string_typecast_bytesize
+
     # Constructs a new instance of a database connection with the specified
     # options hash.
     #
@@ -98,6 +103,7 @@ module Sequel
     # :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
+    # :check_string_typecast_bytesize :: Whether to check the bytesize of strings before typecasting.
     # :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,
     #                or string with extensions separated by columns.  These extensions are loaded after
@@ -107,7 +113,7 @@ module Sequel
     # :loggers :: An array of loggers to use.
     # :log_connection_info :: Whether connection information should be logged when logging queries.
     # :log_warn_duration :: The number of elapsed seconds after which queries should be logged at warn level.
-    # :name :: A name to use for the Database object, displayed in PoolTimeout .
+    # :name :: A name to use for the Database object, displayed in PoolTimeout.
     # :preconnect :: Automatically create the maximum number of connections, so that they don't
     #                need to be created as needed.  This is useful when connecting takes a long time
     #                and you want to avoid possible latency during runtime.
@@ -116,7 +122,7 @@ module Sequel
     # :preconnect_extensions :: Similar to the :extensions option, but loads the extensions before the
     #                           connections are made by the :preconnect option.
     # :quote_identifiers :: Whether to quote identifiers.
-    # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol .
+    # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol.
     # :single_threaded :: Whether to use a single-threaded connection pool.
     # :sql_log_level :: Method to use to log SQL to a logger, :info by default.
     #
@@ -132,6 +138,7 @@ module Sequel
       @opts[:adapter_class] = self.class
       @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, Sequel.single_threaded))
       @default_string_column_size = @opts[:default_string_column_size] || DEFAULT_STRING_COLUMN_SIZE
+      @check_string_typecast_bytesize = typecast_value_boolean(@opts.fetch(:check_string_typecast_bytesize, true))
 
       @schemas = {}
       @prepared_statements = {}
@@ -350,7 +357,7 @@ module Sequel
     # strings with all whitespace, and ones that respond
     # true to empty?
     def blank_object?(obj)
-      return obj.blank? if defined?(obj.blank?)
+      return obj.blank? if obj.respond_to?(:blank?)
       case obj
       when NilClass, FalseClass
         true
@@ -359,7 +366,7 @@ module Sequel
       when String
         obj.strip.empty?
       else
-        defined?(obj.empty?) ? obj.empty? : false
+        obj.respond_to?(:empty?) ? obj.empty? : false
       end
     end
 
@@ -465,6 +472,21 @@ module Sequel
     #   Don't rescue other exceptions, they will be raised normally.
     end
 
+    # Check the bytesize of a string before conversion. There is no point
+    # trying to typecast strings that would be way too long.
+    def typecast_check_string_length(string, max_size)
+      if @check_string_typecast_bytesize && string.bytesize > max_size
+        raise InvalidValue, "string too long to typecast (bytesize: #{string.bytesize}, max: #{max_size})"
+      end
+      string
+    end
+
+    # Check the bytesize of the string value, if value is a string.
+    def typecast_check_length(value, max_size)
+      typecast_check_string_length(value, max_size) if String === value
+      value
+    end
+
     # Typecast the value to an SQL::Blob
     def typecast_value_blob(value)
       value.is_a?(Sequel::SQL::Blob) ? value : Sequel::SQL::Blob.new(value)
@@ -488,9 +510,9 @@ module Sequel
       when Date
         value
       when String
-        Sequel.string_to_date(value)
+        Sequel.string_to_date(typecast_check_string_length(value, 100))
       when Hash
-        Date.new(*[:year, :month, :day].map{|x| (value[x] || value[x.to_s]).to_i})
+        Date.new(*[:year, :month, :day].map{|x| typecast_check_length(value[x] || value[x.to_s], 100).to_i})
       else
         raise InvalidValue, "invalid value for Date: #{value.inspect}"
       end
@@ -498,7 +520,17 @@ module Sequel
 
     # Typecast the value to a DateTime or Time depending on Sequel.datetime_class
     def typecast_value_datetime(value)
-      Sequel.typecast_to_application_timestamp(value)
+      case value
+      when String
+        Sequel.typecast_to_application_timestamp(typecast_check_string_length(value, 100))
+      when Hash
+        [:year, :month, :day, :hour, :minute, :second, :nanos, :offset].each do |x|
+          typecast_check_length(value[x] || value[x.to_s], 100)
+        end
+        Sequel.typecast_to_application_timestamp(value)
+      else
+        Sequel.typecast_to_application_timestamp(value)
+      end
     end
     
     if RUBY_VERSION >= '2.4'
@@ -531,18 +563,30 @@ module Sequel
       when Numeric
         BigDecimal(value.to_s)
       when String
-        _typecast_value_string_to_decimal(value)
+        _typecast_value_string_to_decimal(typecast_check_string_length(value, 1000))
       else
         raise InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
       end
     end
 
     # Typecast the value to a Float
-    alias typecast_value_float Float
+    def typecast_value_float(value)
+      Float(typecast_check_length(value, 1000))
+    end
 
     # Typecast the value to an Integer
     def typecast_value_integer(value)
-      (value.is_a?(String) && value =~ /\A0+(\d)/) ? Integer(value, 10) : Integer(value)
+      case value
+      when String
+        typecast_check_string_length(value, 100)
+        if value =~ /\A-?0+(\d)/
+          Integer(value, 10)
+        else
+          Integer(value)
+        end
+      else
+        Integer(value)
+      end
     end
 
     # Typecast the value to a String
@@ -565,9 +609,9 @@ module Sequel
           SQLTime.create(value.hour, value.min, value.sec, value.nsec/1000.0)
         end
       when String
-        Sequel.string_to_time(value)
+        Sequel.string_to_time(typecast_check_string_length(value, 100))
       when Hash
-        SQLTime.create(*[:hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
+        SQLTime.create(*[:hour, :minute, :second].map{|x| typecast_check_length(value[x] || value[x.to_s], 100).to_i})
       else
         raise Sequel::InvalidValue, "invalid value for Time: #{value.inspect}"
       end

data/lib/sequel/dataset/sql.rb

@@ -1398,9 +1398,9 @@ module Sequel
       # don't cache SQL for a dataset that uses this.
       disable_sql_caching!
 
-      if defined?(v.sql_literal_append)
+      if v.respond_to?(:sql_literal_append)
         v.sql_literal_append(self, sql)
-      elsif defined?(v.sql_literal)
+      elsif v.respond_to?(:sql_literal)
         sql << v.sql_literal(self)
       else
         raise Error, "can't express #{v.inspect} as a SQL literal"

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -77,7 +77,7 @@ module Sequel
     def duplicate_columns_handler_type(cols)
       handler = opts.fetch(:on_duplicate_columns){db.opts.fetch(:on_duplicate_columns, :warn)}
 
-      if defined?(handler.call)
+      if handler.respond_to?(:call)
         handler.call(cols)
       else
         handler

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

@@ -301,7 +301,7 @@ module Sequel
         end
       end
 
-      unless defined?(Sequel::Postgres.parse_pg_array)
+      unless Sequel::Postgres.respond_to?(:parse_pg_array)
         require 'strscan'
 
         # PostgreSQL array parser that handles PostgreSQL array output format.
@@ -412,7 +412,7 @@ module Sequel
           @converter = converter
         end
 
-        if defined?(Sequel::Postgres.parse_pg_array)
+        if Sequel::Postgres.respond_to?(:parse_pg_array)
         # :nocov:
           # Use sequel_pg's C-based parser if it has already been defined.
           def call(string)

data/lib/sequel/extensions/pg_array_ops.rb

@@ -158,7 +158,7 @@ module Sequel
           Sequel.function(:hstore, self, wrap_array(arg))
         end
         # :nocov:
-        if defined?(Sequel.hstore_op)
+        if Sequel.respond_to?(:hstore_op)
         # :nocov:
           v = Sequel.hstore_op(v)
         end

data/lib/sequel/extensions/pg_enum.rb

@@ -144,7 +144,7 @@ module Sequel
           select_hash_groups(Sequel.cast(:enumtypid, Integer).as(:v), :enumlabel).freeze
         enum_labels.each_value(&:freeze)
 
-        if defined?(register_array_type)
+        if respond_to?(:register_array_type)
           array_types = metadata_dataset.
             from(:pg_type).
             where(:oid=>enum_labels.keys).

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -29,6 +29,8 @@ module Sequel
       INFINITE_DATETIME_VALUES = ([PLUS_INFINITY, MINUS_INFINITY] + INFINITE_TIMESTAMP_STRINGS).freeze
       PLUS_DATE_INFINITY = Date::Infinity.new
       MINUS_DATE_INFINITY = -PLUS_DATE_INFINITY
+      RATIONAL_60 = Rational(60)
+      TIME_CAN_PARSE_BC = RUBY_VERSION >= '2.5'
 
       # Add dataset methods and update the conversion proces for dates and timestamps.
       def self.extended(db)
@@ -86,27 +88,18 @@ module Sequel
         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'
           end
-          if m[2] || conv
-            dt = DateTime.parse(value)
-            if conv
-              # :nocov:
-              if Sequel.datetime_class == DateTime
-                dt >>= 12
-              else
-                dt >>= 24
-              end
-              # :nocov:
-            end
-            unless Sequel.datetime_class == DateTime
-              dt = dt.to_time
-              if conv && (timezone == nil || timezone == :local) && !m[1]
-                # :nocov:
-                dt = Sequel.send(:convert_input_timestamp, dt.strftime("%F %T.%6N"), :local)
-                # :nocov:
-              end
+          if m[2]
+            dt = if Sequel.datetime_class == DateTime
+              DateTime.parse(value)
+            elsif TIME_CAN_PARSE_BC
+              Time.parse(value)
+            # :nocov:
+            else
+              DateTime.parse(value).to_time
+            # :nocov:
             end
+
             Sequel.convert_output_timestamp(dt, Sequel.application_timezone)
           else
             super(value)
@@ -223,10 +216,7 @@ module Sequel
           # Work around JRuby bug #4822 in Time#to_datetime for times before date of calendar reform
           def literal_time(time)
             if time < TIME_YEAR_1
-              dt = DateTime.parse(super)
-              # Work around JRuby bug #5191
-              dt >>= 12 if JRUBY_VERSION == '9.2.0.0'
-              literal_datetime(dt)
+              literal_datetime(DateTime.parse(super))
             else
               super
             end
@@ -236,7 +226,8 @@ module Sequel
           # Handle BC Time objects.
           def literal_time(time)
             if time < TIME_YEAR_1
-              literal_datetime(time.to_datetime)
+              time = db.from_application_timestamp(time)
+              time.strftime("'#{sprintf('%04i', time.year.abs+1)}-%m-%d %H:%M:%S.%N#{format_timestamp_offset(*(time.utc_offset/RATIONAL_60).divmod(60))} BC'")
             else
               super
             end

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -296,7 +296,7 @@ module Sequel
 
       # Wrap argument in a PGArray if it is an array
       def wrap_input_array(obj)
-        if obj.is_a?(Array) && defined?(Sequel.pg_array) 
+        if obj.is_a?(Array) && Sequel.respond_to?(:pg_array) 
           Sequel.pg_array(obj)
         else
           obj
@@ -305,7 +305,7 @@ module Sequel
 
       # Wrap argument in an Hstore if it is a hash
       def wrap_input_hash(obj)
-        if obj.is_a?(Hash) && defined?(Sequel.hstore) 
+        if obj.is_a?(Hash) && Sequel.respond_to?(:hstore) 
           Sequel.hstore(obj)
         else
           obj
@@ -314,7 +314,7 @@ module Sequel
 
       # Wrap argument in a PGArrayOp if supported
       def wrap_output_array(obj)
-        if defined?(Sequel.pg_array_op) 
+        if Sequel.respond_to?(:pg_array_op) 
           Sequel.pg_array_op(obj)
         else
           obj

data/lib/sequel/extensions/pg_inet.rb

@@ -49,13 +49,13 @@ module Sequel
             meth = IPAddr.method(:new)
             add_conversion_proc(869, meth)
             add_conversion_proc(650, meth)
-            if defined?(register_array_type)
+            if respond_to?(:register_array_type)
               register_array_type('inet', :oid=>1041, :scalar_oid=>869)
               register_array_type('cidr', :oid=>651, :scalar_oid=>650)
             end
           end
 
-          if defined?(register_array_type)
+          if respond_to?(:register_array_type)
             register_array_type('macaddr', :oid=>1040, :scalar_oid=>829)
           end
           @schema_type_classes[:ipaddr] = IPAddr
@@ -111,7 +111,7 @@ module Sequel
         when IPAddr
           value
         when String
-          IPAddr.new(value)
+          IPAddr.new(typecast_check_string_length(value, 100))
         else
           raise Sequel::InvalidValue, "invalid value for inet/cidr: #{value.inspect}"
         end

data/lib/sequel/extensions/pg_interval.rb

@@ -144,7 +144,7 @@ module Sequel
         db.instance_exec do
           extend_datasets(IntervalDatasetMethods)
           add_conversion_proc(1186, Postgres::IntervalDatabaseMethods::PARSER)
-          if defined?(register_array_type)
+          if respond_to?(:register_array_type)
             register_array_type('interval', :oid=>1187, :scalar_oid=>1186)
           end
           @schema_type_classes[:interval] = ActiveSupport::Duration
@@ -197,7 +197,7 @@ module Sequel
         when Numeric
           ActiveSupport::Duration.new(value, [[:seconds, value]])
         when String
-          PARSER.call(value)
+          PARSER.call(typecast_check_string_length(value, 1000))
         else
           raise Sequel::InvalidValue, "invalid value for interval type: #{value.inspect}"
         end

data/lib/sequel/extensions/pg_json.rb

@@ -227,7 +227,7 @@ module Sequel
         db.instance_exec do
           add_conversion_proc(114, method(:_db_parse_json))
           add_conversion_proc(3802, method(:_db_parse_jsonb))
-          if defined?(register_array_type)
+          if respond_to?(:register_array_type)
             register_array_type('json', :oid=>199, :scalar_oid=>114)
             register_array_type('jsonb', :oid=>3807, :scalar_oid=>3802)
           end

data/lib/sequel/extensions/pg_json_ops.rb

@@ -123,15 +123,6 @@
 #   c = Sequel.pg_jsonb_op(:c)
 #   DB[:t].update(c['key1'] => 1.to_json, c['key2'] => "a".to_json)
 #
-# On PostgreSQL 15+, the <tt>IS [NOT] JSON</tt> operator is supported:
-#
-#   j.is_json                              # j IS JSON
-#   j.is_json(type: :object)               # j IS JSON OBJECT
-#   j.is_json(type: :object, unique: true) # j IS JSON OBJECT WITH UNIQUE
-#   j.is_not_json                          # j IS NOT JSON
-#   j.is_json(type: :array)                # j IS NOT JSON ARRAY
-#   j.is_json(unique: true)                # j IS NOT JSON WITH UNIQUE
-#
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
 # JSONHash, JSONHarray, JSONBHash, and JSONBArray, allowing you to perform json/jsonb operations
@@ -160,18 +151,6 @@ module Sequel
       GET_PATH = ["(".freeze, " #> ".freeze, ")".freeze].freeze
       GET_PATH_TEXT = ["(".freeze, " #>> ".freeze, ")".freeze].freeze
 
-      IS_JSON = ["(".freeze, " IS JSON".freeze, "".freeze, ")".freeze].freeze
-      IS_NOT_JSON = ["(".freeze, " IS NOT JSON".freeze, "".freeze, ")".freeze].freeze
-      EMPTY_STRING = Sequel::LiteralString.new('').freeze
-      WITH_UNIQUE = Sequel::LiteralString.new(' WITH UNIQUE').freeze
-      IS_JSON_MAP = {
-        nil => EMPTY_STRING,
-        :value => Sequel::LiteralString.new(' VALUE').freeze,
-        :scalar => Sequel::LiteralString.new(' SCALAR').freeze,
-        :object => Sequel::LiteralString.new(' OBJECT').freeze,
-        :array => Sequel::LiteralString.new(' ARRAY').freeze
-      }.freeze
-
       # Get JSON array element or object field as json.  If an array is given,
       # gets the object at the specified path.
       #
@@ -254,30 +233,6 @@ module Sequel
         end
       end
 
-      # Return whether the json object can be parsed as JSON.
-      #
-      # Options:
-      # :type :: Check whether the json object can be parsed as a specific type
-      #          of JSON (:value, :scalar, :object, :array).
-      # :unique :: Check JSON objects for unique keys.
-      #
-      #   json_op.is_json                 # json IS JSON
-      #   json_op.is_json(type: :object)  # json IS JSON OBJECT
-      #   json_op.is_json(unique: true)   # json IS JSON WITH UNIQUE
-      def is_json(opts=OPTS)
-        _is_json(IS_JSON, opts)
-      end
-
-      # Return whether the json object cannot be parsed as JSON. The opposite
-      # of #is_json. See #is_json for options.
-      #
-      #   json_op.is_not_json                 # json IS NOT JSON
-      #   json_op.is_not_json(type: :object)  # json IS NOT JSON OBJECT
-      #   json_op.is_not_json(unique: true)   # json IS NOT JSON WITH UNIQUE
-      def is_not_json(opts=OPTS)
-        _is_json(IS_NOT_JSON, opts)
-      end
-
       # Returns a set of keys AS text in the json object.
       #
       #   json_op.keys # json_object_keys(json)
@@ -331,13 +286,6 @@ module Sequel
 
       private
 
-      # Internals of IS [NOT] JSON support
-      def _is_json(lit_array, opts)
-        raise Error, "invalid is_json :type option: #{opts[:type].inspect}" unless type = IS_JSON_MAP[opts[:type]]
-        unique = opts[:unique] ? WITH_UNIQUE : EMPTY_STRING
-        Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(lit_array, [self, type, unique]))
-      end
-
       # Return a placeholder literal with the given str and args, wrapped
       # in an JSONOp or JSONBOp, used by operators that return json or jsonb.
       def json_op(str, args)
@@ -358,7 +306,7 @@ module Sequel
       # Automatically wrap argument in a PGArray if it is a plain Array.
       # Requires that the pg_array extension has been loaded to work.
       def wrap_array(arg)
-        if arg.instance_of?(Array) && defined?(Sequel.pg_array)
+        if arg.instance_of?(Array) && Sequel.respond_to?(:pg_array)
           Sequel.pg_array(arg)
         else
           arg
@@ -652,7 +600,7 @@ module Sequel
 
       # Wrap argument in a PGArray if it is an array
       def wrap_input_array(obj)
-        if obj.is_a?(Array) && defined?(Sequel.pg_array) 
+        if obj.is_a?(Array) && Sequel.respond_to?(:pg_array) 
           Sequel.pg_array(obj)
         else
           obj
@@ -661,7 +609,7 @@ module Sequel
 
       # Wrap argument in a JSONBArray or JSONBHash if it is an array or hash.
       def wrap_input_jsonb(obj)
-        if defined?(Sequel.pg_jsonb) && (obj.is_a?(Array) || obj.is_a?(Hash))
+        if Sequel.respond_to?(:pg_jsonb) && (obj.is_a?(Array) || obj.is_a?(Hash))
           Sequel.pg_jsonb(obj)
         else
           obj

data/lib/sequel/extensions/pg_multirange.rb

@@ -124,7 +124,7 @@ module Sequel
             register_multirange_type('datemultirange', :range_oid=>3912, :oid=>4535)
             register_multirange_type('int8multirange', :range_oid=>3926, :oid=>4536)
 
-            if defined?(register_array_type)
+            if respond_to?(:register_array_type)
               register_array_type('int4multirange', :oid=>6150, :scalar_oid=>4451, :scalar_typecast=>:int4multirange)
               register_array_type('nummultirange', :oid=>6151, :scalar_oid=>4532, :scalar_typecast=>:nummultirange)
               register_array_type('tsmultirange', :oid=>6152, :scalar_oid=>4533, :scalar_typecast=>:tsmultirange)
@@ -141,7 +141,7 @@ module Sequel
             add_conversion_proc(4533, PGMultiRange::Creator.new("tsmultirange", procs[3908]))
             add_conversion_proc(4534, PGMultiRange::Creator.new("tstzmultirange", procs[3910]))
 
-            if defined?(register_array_type) && defined?(PGArray::Creator)
+            if respond_to?(:register_array_type) && defined?(PGArray::Creator)
               add_conversion_proc(6152, PGArray::Creator.new("tsmultirange", procs[4533]))
               add_conversion_proc(6153, PGArray::Creator.new("tstzmultirange", procs[4534]))
             end

data/lib/sequel/extensions/pg_range.rb

@@ -139,7 +139,7 @@ module Sequel
             register_range_type('tstzrange', :oid=>3910, :subtype_oid=>1184)
             register_range_type('daterange', :oid=>3912, :subtype_oid=>1082)
             register_range_type('int8range', :oid=>3926, :subtype_oid=>20)
-            if defined?(register_array_type)
+            if respond_to?(:register_array_type)
               register_array_type('int4range', :oid=>3905, :scalar_oid=>3904, :scalar_typecast=>:int4range)
               register_array_type('numrange', :oid=>3907, :scalar_oid=>3906, :scalar_typecast=>:numrange)
               register_array_type('tsrange', :oid=>3909, :scalar_oid=>3908, :scalar_typecast=>:tsrange)
@@ -154,7 +154,7 @@ module Sequel
             procs = conversion_procs
             add_conversion_proc(3908, Parser.new("tsrange", procs[1114]))
             add_conversion_proc(3910, Parser.new("tstzrange", procs[1184]))
-            if defined?(register_array_type) && defined?(PGArray::Creator)
+            if respond_to?(:register_array_type) && defined?(PGArray::Creator)
               add_conversion_proc(3909, PGArray::Creator.new("tsrange", procs[3908]))
               add_conversion_proc(3911, PGArray::Creator.new("tstzrange", procs[3910]))
             end
@@ -282,7 +282,7 @@ module Sequel
           when Range
             PGRange.from_range(value, parser.db_type)
           when String
-            parser.call(value)
+            parser.call(typecast_check_string_length(value, 100))
           else
             raise Sequel::InvalidValue, "invalid value for range type: #{value.inspect}"
           end

data/lib/sequel/extensions/pg_row.rb

@@ -375,7 +375,7 @@ module Sequel
             @row_schema_types = {}
             extend(@row_type_method_module = Module.new)
             add_conversion_proc(2249, PGRow::Parser.new(:converter=>PGRow::ArrayRow))
-            if defined?(register_array_type)
+            if respond_to?(:register_array_type)
               register_array_type('record', :oid=>2287, :scalar_oid=>2249)
             end
           end
@@ -464,7 +464,7 @@ module Sequel
           parser = Parser.new(parser_opts)
           add_conversion_proc(parser.oid, parser)
 
-          if defined?(register_array_type) && array_oid && array_oid > 0
+          if respond_to?(:register_array_type) && array_oid && array_oid > 0
             array_type_name = if type_schema
               "#{type_schema}.#{type_name}"
             else

data/lib/sequel/extensions/pg_static_cache_updater.rb

@@ -115,13 +115,13 @@ SQL
       # :before_thread_exit :: An object that responds to +call+ that is called before the 
       #                        the created thread exits.
       def listen_for_static_cache_updates(models, opts=OPTS)
-        raise Error, "this database object does not respond to listen, use the postgres adapter with the pg driver" unless defined?(listen)
+        raise Error, "this database object does not respond to listen, use the postgres adapter with the pg driver" unless respond_to?(:listen)
         models = [models] unless models.is_a?(Array)
         raise Error, "array of models to listen for changes cannot be empty" if models.empty?
 
         oid_map = {}
         models.each do |model|
-          raise Error, "#{model.inspect} does not use the static_cache plugin" unless defined?(model.load_cache)
+          raise Error, "#{model.inspect} does not use the static_cache plugin" unless model.respond_to?(:load_cache)
           oid_map[get(regclass_oid(model.dataset.first_source_table))] = model
         end
 

data/lib/sequel/model/associations.rb

@@ -3016,7 +3016,7 @@ module Sequel
         def complex_expression_sql_append(sql, op, args)
           r = args[1]
           if (((op == :'=' || op == :'!=') && r.is_a?(Sequel::Model)) ||
-              (multiple = ((op == :IN || op == :'NOT IN') && ((is_ds = r.is_a?(Sequel::Dataset)) || (defined?(r.all?) && r.all?{|x| x.is_a?(Sequel::Model)})))))
+              (multiple = ((op == :IN || op == :'NOT IN') && ((is_ds = r.is_a?(Sequel::Dataset)) || (r.respond_to?(:all?) && r.all?{|x| x.is_a?(Sequel::Model)})))))
             l = args[0]
             if ar = model.association_reflections[l]
               raise Error, "filtering by associations is not allowed for #{ar.inspect}" if ar[:allow_filtering_by] == false
@@ -3024,7 +3024,7 @@ module Sequel
               if multiple
                 klass = ar.associated_class
                 if is_ds
-                  if defined?(r.model)
+                  if r.respond_to?(:model)
                     unless r.model <= klass
                       # A dataset for a different model class, could be a valid regular query
                       return super
@@ -3356,10 +3356,10 @@ module Sequel
           assoc_table_alias = ds.unused_table_alias(alias_base)
           loader = r[:eager_grapher]
           if !associations.empty?
-            if defined?(associations.first.call)
+            if associations.first.respond_to?(:call)
               callback = associations.first
               associations = {}
-            elsif associations.length == 1 && (assocs = associations.first).is_a?(Hash) && assocs.length == 1 && (pr_assoc = assocs.to_a.first) && defined?(pr_assoc.first.call)
+            elsif associations.length == 1 && (assocs = associations.first).is_a?(Hash) && assocs.length == 1 && (pr_assoc = assocs.to_a.first) && pr_assoc.first.respond_to?(:call)
               callback, assoc = pr_assoc
               associations = assoc.is_a?(Array) ? assoc : [assoc]
             end
@@ -3601,10 +3601,10 @@ module Sequel
             end
           
             associations = eager_assoc[r[:name]]
-            if defined?(associations.call)
+            if associations.respond_to?(:call)
               eager_block = associations
               associations = OPTS
-            elsif associations.is_a?(Hash) && associations.length == 1 && (pr_assoc = associations.to_a.first) && defined?(pr_assoc.first.call)
+            elsif associations.is_a?(Hash) && associations.length == 1 && (pr_assoc = associations.to_a.first) && pr_assoc.first.respond_to?(:call)
               eager_block, associations = pr_assoc
             end
 

data/lib/sequel/model/base.rb

@@ -492,13 +492,13 @@ module Sequel
       def plugin(plugin, *args, &block)
         m = plugin.is_a?(Module) ? plugin : plugin_module(plugin)
 
-        if !defined?(m.apply) && !defined?(m.configure) && (!args.empty? || block)
+        if !m.respond_to?(:apply) && !m.respond_to?(:configure) && (!args.empty? || block)
           Deprecation.deprecate("Plugin #{plugin} accepts no arguments or block, and passing arguments/block to it", "Remove arguments and block when loading the plugin")
         end
 
         unless @plugins.include?(m)
           @plugins << m
-          m.apply(self, *args, &block) if defined?(m.apply)
+          m.apply(self, *args, &block) if m.respond_to?(:apply)
           extend(m::ClassMethods) if m.const_defined?(:ClassMethods, false)
           include(m::InstanceMethods) if m.const_defined?(:InstanceMethods, false)
           if m.const_defined?(:DatasetMethods, false)
@@ -506,7 +506,7 @@ module Sequel
           end
         end
 
-        m.configure(self, *args, &block) if defined?(m.configure)
+        m.configure(self, *args, &block) if m.respond_to?(:configure)
       end
       # :nocov:
       ruby2_keywords(:plugin) if respond_to?(:ruby2_keywords, true)

data/lib/sequel/model/exceptions.rb

@@ -44,7 +44,7 @@ module Sequel
         errors = @model.errors
       end
 
-      if defined?(errors.full_messages)
+      if errors.respond_to?(:full_messages)
         @errors = errors
         super(errors.full_messages.join(', '))
       else

data/lib/sequel/model/inflections.rb

@@ -99,7 +99,7 @@ module Sequel
     # Convert the given string to CamelCase.  Will also convert '/' to '::' which is useful for converting paths to namespaces.
     def camelize(s)
       s = s.to_s
-      return s.camelize if defined?(s.camelize)
+      return s.camelize if s.respond_to?(:camelize)
       s = s.gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
       s
     end
@@ -109,7 +109,7 @@ module Sequel
     # or is not initialized.
     def constantize(s)
       s = s.to_s
-      return s.constantize if defined?(s.constantize)
+      return s.constantize if s.respond_to?(:constantize)
       raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(s)
       Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
     end
@@ -117,14 +117,14 @@ module Sequel
     # Removes the module part from the expression in the string
     def demodulize(s)
       s = s.to_s
-      return s.demodulize if defined?(s.demodulize)
+      return s.demodulize if s.respond_to?(:demodulize)
       s.gsub(/^.*::/, '')
     end
   
     # Returns the plural form of the word in the string.
     def pluralize(s)
       s = s.to_s
-      return s.pluralize if defined?(s.pluralize)
+      return s.pluralize if s.respond_to?(:pluralize)
       result = s.dup
       Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
       result
@@ -133,7 +133,7 @@ module Sequel
     # The reverse of pluralize, returns the singular form of a word in a string.
     def singularize(s)
       s = s.to_s
-      return s.singularize if defined?(s.singularize)
+      return s.singularize if s.respond_to?(:singularize)
       result = s.dup
       Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
       result
@@ -143,7 +143,7 @@ module Sequel
     # Also changes '::' to '/' to convert namespaces to paths.
     def underscore(s)
       s = s.to_s
-      return s.underscore if defined?(s.underscore)
+      return s.underscore if s.respond_to?(:underscore)
       s.gsub('::', '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
         gsub(/([a-z\d])([A-Z])/, '\1_\2').tr('-', '_').downcase
     end

data/lib/sequel/plugins/auto_validations.rb

@@ -252,7 +252,7 @@ module Sequel
 
           unless skip.include?(:unique)
             unique_opts = Hash[opts[:unique]]
-            if defined?(model.sti_dataset)
+            if model.respond_to?(:sti_dataset)
               unique_opts[:dataset] = model.sti_dataset
             end
             model.auto_validate_unique_columns.each{|cols| validates_unique(cols, unique_opts)}

data/lib/sequel/plugins/defaults_setter.rb

@@ -117,7 +117,7 @@ module Sequel
         def [](k)
           if new? && !values.has_key?(k)
             v = model.default_values.fetch(k){return}
-            v = v.call if defined?(v.call)
+            v = v.call if v.respond_to?(:call)
             values[k] = v if model.cache_default_values?
             v
           else

data/lib/sequel/plugins/dirty.rb

@@ -203,7 +203,7 @@ module Sequel
             get_column_value(column)
           end
 
-          initial_values[column] = if value && value != true && defined?(value.clone)
+          initial_values[column] = if value && value != true && value.respond_to?(:clone)
             begin
               value.clone
             rescue TypeError

data/lib/sequel/plugins/insert_conflict.rb

@@ -36,7 +36,7 @@ module Sequel
     module InsertConflict
       def self.configure(model)
         model.instance_exec do
-          if @dataset && !defined?(@dataset.insert_conflict)
+          if @dataset && !@dataset.respond_to?(:insert_conflict)
             raise Error, "#{self}'s dataset does not support insert_conflict"
           end
         end

data/lib/sequel/plugins/json_serializer.rb

@@ -152,7 +152,7 @@ module Sequel
         if obj.is_a?(Array)
           obj.map{|x| object_to_json_data(x, *args, &block)}
         else
-          if defined?(obj.to_json_data)
+          if obj.respond_to?(:to_json_data)
             obj.to_json_data(*args, &block)
           else
             begin

data/lib/sequel/plugins/nested_attributes.rb

@@ -259,7 +259,7 @@ module Sequel
         # specific :fields if configured.
         def nested_attributes_set_attributes(meta, obj, attributes)
           if fields = meta[:fields]
-            fields = fields.call(obj) if defined?(fields.call)
+            fields = fields.call(obj) if fields.respond_to?(:call)
             obj.set_fields(attributes, fields, :missing=>:skip)
           else
             obj.set(attributes)

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -159,7 +159,7 @@ module Sequel
 
           case @dataset.first_source_table
           when Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier
-           convert_errors = defined?(db.error_info)
+           convert_errors = db.respond_to?(:error_info)
           end
 
           unless convert_errors

data/lib/sequel/plugins/serialization.rb

@@ -162,7 +162,7 @@ module Sequel
                 if !cc.include?(column) && (new? || get_column_value(column) != v)
                   cc << column
 
-                  will_change_column(column) if defined?(will_change_column)
+                  will_change_column(column) if respond_to?(:will_change_column)
                 end
 
                 deserialized_values[column] = v

data/lib/sequel/plugins/sharding.rb

@@ -91,7 +91,7 @@ module Sequel
         # +many_to_many+ association, make sure the associated object is created on the
         # current object's shard, unless the passed object already has an assigned shard.
         def ensure_associated_primary_key(opts, o, *args)
-          o.set_server?(@server) if defined?(o.set_server?)
+          o.set_server?(@server) if o.respond_to?(:set_server?)
           super
         end
 

data/lib/sequel/plugins/subclasses.rb

@@ -35,7 +35,7 @@ module Sequel
     #   class B < Sequel::Model; end
     #   a # => [A, B]
     module Subclasses
-      NEED_SUBCLASSES = !defined?(Object.subclasses) || Object.method(:subclasses).source_location
+      NEED_SUBCLASSES = !Object.respond_to?(:subclasses) || Object.method(:subclasses).source_location
       private_constant :NEED_SUBCLASSES
 
       # Initialize the subclasses instance variable for the model.

data/lib/sequel/plugins/validation_class_methods.rb

@@ -282,7 +282,7 @@ module Sequel
               o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && v.size == i
             end
             if w = opts[:within]
-              o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && w.public_send(defined?(w.cover?) ? :cover? : :include?, v.size)
+              o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && w.public_send(w.respond_to?(:cover?) ? :cover? : :include?, v.size)
             end
           end
         end
@@ -337,14 +337,14 @@ module Sequel
         def validates_inclusion_of(*atts)
           opts = extract_options!(atts)
           n = opts[:in]
-          unless n && (defined?(n.cover?) || defined?(n.include?))
+          unless n && (n.respond_to?(:cover?) || n.respond_to?(:include?))
             raise ArgumentError, "The :in parameter is required, and must respond to cover? or include?"
           end
           opts[:message] ||= "is not in range or set: #{n.inspect}"
           reflect_validation(:inclusion, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
-            o.errors.add(a, opts[:message]) unless n.public_send(defined?(n.cover?) ? :cover? : :include?, v)
+            o.errors.add(a, opts[:message]) unless n.public_send(n.respond_to?(:cover?) ? :cover? : :include?, v)
           end
         end
     

data/lib/sequel/plugins/validation_helpers.rb

@@ -107,7 +107,7 @@ module Sequel
     
         # Check attribute value(s) is included in the given set.
         def validates_includes(set, atts, opts=OPTS)
-          validatable_attributes_for_type(:includes, atts, opts){|a,v,m| validation_error_message(m, set) unless set.public_send(defined?(set.cover?) ? :cover? : :include?, v)}
+          validatable_attributes_for_type(:includes, atts, opts){|a,v,m| validation_error_message(m, set) unless set.public_send(set.respond_to?(:cover?) ? :cover? : :include?, v)}
         end
     
         # Check attribute value(s) string representation is a valid integer.

data/lib/sequel/sql.rb

@@ -1347,7 +1347,7 @@ module Sequel
       # underlying callable only accepts a single argument, call it
       # with the given dataset.
       def call(ds)
-        if defined?(@callable.arity) && @callable.arity == 1
+        if @callable.respond_to?(:arity) && @callable.arity == 1
           @callable.call(ds)
         else
           @callable.call

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 60
+  MINOR = 61
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.60.0
+  version: 5.61.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-01 00:00:00.000000000 Z
+date: 2022-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -192,6 +192,7 @@ extra_rdoc_files:
 - doc/release_notes/5.59.0.txt
 - doc/release_notes/5.6.0.txt
 - doc/release_notes/5.60.0.txt
+- doc/release_notes/5.61.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
@@ -280,6 +281,7 @@ files:
 - doc/release_notes/5.59.0.txt
 - doc/release_notes/5.6.0.txt
 - doc/release_notes/5.60.0.txt
+- doc/release_notes/5.61.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt