sequel 5.58.0 → 5.78.0

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -22,13 +22,14 @@
 module Sequel
   module Postgres
     module ExtendedDateSupport
-      DATE_YEAR_1 = Date.new(1)
       DATETIME_YEAR_1 = DateTime.new(1)
       TIME_YEAR_1 = Time.at(-62135596800).utc
       INFINITE_TIMESTAMP_STRINGS = ['infinity'.freeze, '-infinity'.freeze].freeze
       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)
@@ -36,6 +37,27 @@ module Sequel
         procs = db.conversion_procs
         procs[1082] = ::Sequel.method(:string_to_date)
         procs[1184] = procs[1114] = db.method(:to_application_timestamp)
+        if ocps = db.instance_variable_get(:@oid_convertor_map)
+          # Clear the oid convertor map entries for timestamps if they
+          # exist, so it will regenerate new ones that use this extension.
+          # This is only taken when using the jdbc adapter.
+          Sequel.synchronize do
+            ocps.delete(1184)
+            ocps.delete(1114)
+          end
+        end
+      end
+
+      # Handle BC dates and times in bound variables. This is necessary for Date values
+      # when using both the postgres and jdbc adapters, but also necessary for Time values
+      # on jdbc.
+      def bound_variable_arg(arg, conn)
+        case arg
+        when Time, Date
+          @default_dataset.literal_date_or_time(arg)
+        else
+          super
+        end
       end
 
       # Whether infinite timestamps/dates should be converted on retrieval.  By default, no
@@ -86,27 +108,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)
@@ -176,7 +189,7 @@ module Sequel
 
         # Handle BC Date objects.
         def literal_date(date)
-          if date < DATE_YEAR_1
+          if date.year < 1
             date <<= ((date.year) * 24 - 12)
             date.strftime("'%Y-%m-%d BC'")
           else
@@ -190,7 +203,7 @@ module Sequel
             date <<= ((date.year) * 24 - 12)
             date = db.from_application_timestamp(date)
             minutes = (date.offset * 1440).to_i
-            date.strftime("'%Y-%m-%d %H:%M:%S.%N#{format_timestamp_offset(*minutes.divmod(60))} BC'")
+            date.strftime("'%Y-%m-%d %H:%M:%S.%6N#{sprintf("%+03i%02i", *minutes.divmod(60))} BC'")
           else
             super
           end
@@ -223,10 +236,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 +246,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.%6N#{sprintf("%+03i%02i", *(time.utc_offset/RATIONAL_60).divmod(60))} BC'")
             else
               super
             end

data/lib/sequel/extensions/pg_extended_integer_support.rb

@@ -0,0 +1,116 @@
+# frozen-string-literal: true
+#
+# The pg_extended_integer_support extension supports literalizing
+# Ruby integers outside of PostgreSQL bigint range on PostgreSQL.
+# Sequel by default will raise exceptions when
+# literalizing such integers, as PostgreSQL would treat them
+# as numeric type values instead of integer/bigint type values
+# if unquoted, which can result in unexpected negative performance
+# (e.g. forcing sequential scans when index scans would be used for
+# an integer/bigint type).
+#
+# To load the extension into a Dataset (this returns a new Dataset):
+#
+#   dataset = dataset.extension(:pg_extended_integer_support)
+#
+# To load the extension into a Database, so it affects all of the
+# Database's datasets:
+#
+#   DB.extension :pg_extended_integer_support
+#
+# By default, the extension will quote integers outside
+# bigint range:
+#
+#   DB.literal(2**63) # => "'9223372036854775808'"
+#
+# Quoting the value treats the type as unknown:
+#
+#   DB.get{pg_typeof(2**63)} # => 'unknown'
+#
+# PostgreSQL will implicitly cast the unknown type to the appropriate
+# database type, raising an error if it cannot be casted. Be aware this
+# can result in the integer value being implicitly casted to text or
+# any other PostgreSQL type:
+#
+#   # Returns a string, not an integer:
+#   DB.get{2**63}
+#   # => "9223372036854775808"
+#
+# You can use the Dataset#integer_outside_bigint_range_strategy method
+# with the value +:raw+ to change the strategy to not quote the variable:
+#
+#  DB.dataset.
+#    integer_outside_bigint_range_strategy(:raw).
+#    literal(2**63)
+#  # => "9223372036854775808"
+#
+# Note that not quoting the value will result in PostgreSQL treating
+# the type as numeric instead of integer:
+#
+#  DB.dataset.
+#    integer_outside_bigint_range_strategy(:raw).
+#    get{pg_typeof(2**63)}
+#  # => "numeric"
+#
+# The +:raw+ behavior was Sequel's historical behavior, but unless
+# you fully understand the reprecussions of PostgreSQL using a
+# numeric type for integer values, you should not use it.
+#
+# To get the current default behavior of raising an exception for
+# integers outside of PostgreSQL bigint range, you can use a strategy
+# of +:raise+.
+#
+# To specify a default strategy for handling integers outside
+# bigint range that applies to all of a Database's datasets, you can
+# use the +:integer_outside_bigint_range_strategy+ Database option with
+# a value of +:raise+ or +:raw+:
+#
+#   DB.opts[:integer_outside_bigint_range_strategy] = :raw
+#
+# The Database option will be used as a fallback if you did not call
+# the Dataset#integer_outside_bigint_range_strategy method to specify
+# a strategy for the dataset.
+#
+# Related module: Sequel::Postgres::ExtendedIntegerSupport
+
+#
+module Sequel
+  module Postgres
+    module ExtendedIntegerSupport
+      # Set the strategy for handling integers outside PostgreSQL
+      # bigint range.  Supported values:
+      #
+      # :quote :: Quote the integer value. PostgreSQL will treat
+      #           the integer as a unknown type, implicitly casting
+      #           to any other type as needed. This is the default
+      #           value when using the pg_extended_integer_support
+      #           extension.
+      # :raise :: Raise error when attempting to literalize the integer
+      #           (the default behavior of Sequel on PostgreSQL when
+      #           not using the pg_extended_integer_support extension).
+      # :raw :: Use raw integer value without quoting. PostgreSQL
+      #         will treat the integer as a numeric. This was Sequel's
+      #         historical behavior, but it is unlikely to be desired.
+      def integer_outside_bigint_range_strategy(strategy)
+        clone(:integer_outside_bigint_range_strategy=>strategy)
+      end
+
+      private
+
+      # Handle integers outside the bigint range by using
+      # the configured strategy.
+      def literal_integer_outside_bigint_range(v)
+        case @opts[:integer_outside_bigint_range_strategy] || @db.opts[:integer_outside_bigint_range_strategy]
+        when :raise
+          super
+        when :raw
+          v.to_s
+        else # when :quote
+          "'#{v}'"
+        end
+      end
+    end
+  end
+
+  Dataset.register_extension(:pg_extended_integer_support, Postgres::ExtendedIntegerSupport)
+end

data/lib/sequel/extensions/pg_hstore.rb

@@ -280,6 +280,11 @@ module Sequel
         str
       end
 
+      # Allow automatic parameterization.
+      def sequel_auto_param_type(ds)
+        "::hstore"
+      end
+
       private
 
       # Return a new hash based on the input hash with string

data/lib/sequel/extensions/pg_inet.rb

@@ -75,16 +75,6 @@ module Sequel
 
       private
 
-      # Handle inet[]/cidr[] types in bound variables.
-      def bound_variable_array(a)
-        case a
-        when IPAddr
-          "\"#{a.to_s}/#{a.instance_variable_get(:@mask_addr).to_s(2).count('1')}\""
-        else
-          super
-        end
-      end
-
       # Make the column type detection recognize the inet and cidr types.
       def schema_column_type(db_type)
         case db_type
@@ -111,7 +101,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
@@ -121,6 +111,15 @@ module Sequel
     module InetDatasetMethods
       private
 
+      # Allow auto parameterization of IPAddr instances.
+      def auto_param_type_fallback(v)
+        if defined?(super) && (type = super)
+          type
+        elsif IPAddr === v
+          "::inet"
+        end
+      end
+
       # Convert IPAddr value to a string and append a literal version
       # of the string to the sql.
       def literal_other_append(sql, value)

data/lib/sequel/extensions/pg_interval.rb

@@ -163,16 +163,6 @@ module Sequel
 
       private
 
-      # Handle arrays of interval types in bound variables.
-      def bound_variable_array(a)
-        case a
-        when ActiveSupport::Duration
-          "\"#{IntervalDatabaseMethods.literal_duration(a)}\""
-        else
-          super
-        end
-      end
-
       # Set the :ruby_default value if the default value is recognized as an interval.
       def schema_post_process(_)
         super.each do |a|
@@ -197,7 +187,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
@@ -207,6 +197,15 @@ module Sequel
     module IntervalDatasetMethods
       private
 
+      # Allow auto parameterization of ActiveSupport::Duration instances.
+      def auto_param_type_fallback(v)
+        if defined?(super) && (type = super)
+          type
+        elsif ActiveSupport::Duration === v
+          "::interval"
+        end
+      end
+
       # Handle literalization of ActiveSupport::Duration objects, treating them as
       # PostgreSQL intervals.
       def literal_other_append(sql, v)

data/lib/sequel/extensions/pg_json.rb

@@ -142,6 +142,11 @@ module Sequel
           ds.literal_append(sql, Sequel.object_to_json(self))
           sql << '::json'
         end
+
+        # Allow automatic parameterization.
+        def sequel_auto_param_type(ds)
+          "::json"
+        end
       end
 
       jsonb_class = Class.new(base_class) do
@@ -151,6 +156,11 @@ module Sequel
           ds.literal_append(sql, Sequel.object_to_json(self))
           sql << '::jsonb'
         end
+
+        # Allow automatic parameterization.
+        def sequel_auto_param_type(ds)
+          "::jsonb"
+        end
       end
 
       const_set(:"JSON#{name}Base", base_class)
@@ -424,16 +434,6 @@ module Sequel
         end
       end
 
-      # Handle json[] and jsonb[] types in bound variables.
-      def bound_variable_array(a)
-        case a
-        when JSONObject, JSONBObject
-          "\"#{Sequel.object_to_json(a).gsub('"', '\\"')}\""
-        else
-          super
-        end
-      end
-
       # Make the column type detection recognize the json types.
       def schema_column_type(db_type)
         case db_type

data/lib/sequel/extensions/pg_json_ops.rb

@@ -123,6 +123,15 @@
 #   c = Sequel.pg_jsonb_op(:c)
 #   DB[:t].update(c['key1'] => 1.to_json, c['key2'] => "a".to_json)
 #
+# On PostgreSQL 16+, 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_not_json(type: :array)                # j IS NOT JSON ARRAY
+#   j.is_not_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
@@ -151,6 +160,18 @@ 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.
       #
@@ -233,6 +254,30 @@ 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)
@@ -286,6 +331,13 @@ 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)

data/lib/sequel/extensions/pg_multirange.rb

@@ -220,18 +220,8 @@ module Sequel
 
         private
 
-        # Handle arrays of multirange types in bound variables.
-        def bound_variable_array(a)
-          case a
-          when PGMultiRange
-            "\"#{bound_variable_arg(a, nil)}\""
-          else
-            super
-          end
-        end
-
         # Recognize the registered database multirange types.
-        def schema_column_type(db_type)
+        def schema_multirange_type(db_type)
           @pg_multirange_schema_types[db_type] || super
         end
 
@@ -346,6 +336,11 @@ module Sequel
          
         val << "}"
       end
+
+      # Allow automatic parameterization.
+      def sequel_auto_param_type(ds)
+        "::#{db_type}"
+      end
     end
   end
 

data/lib/sequel/extensions/pg_range.rb

@@ -233,18 +233,8 @@ module Sequel
 
         private
 
-        # Handle arrays of range types in bound variables.
-        def bound_variable_array(a)
-          case a
-          when PGRange, Range
-            "\"#{bound_variable_arg(a, nil)}\""
-          else
-            super
-          end
-        end
-
         # Recognize the registered database range types.
-        def schema_column_type(db_type)
+        def schema_range_type(db_type)
           @pg_range_schema_types[db_type] || super
         end
 
@@ -282,7 +272,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
@@ -491,6 +481,11 @@ module Sequel
         end
       end
 
+      # Allow automatic parameterization for ranges with types.
+      def sequel_auto_param_type(ds)
+        "::#{db_type}" if db_type
+      end
+
       private
 
       # Escape common range types.  Instead of quoting, just backslash escape all
@@ -499,8 +494,8 @@ module Sequel
         case k
         when nil
           ''
-        when Date, Time
-          ds.literal(k)[1...-1]
+        when Time, Date
+          ds.literal_date_or_time(k, true)
         when Integer, Float
           k.to_s
         when BigDecimal

data/lib/sequel/extensions/pg_row.rb

@@ -136,6 +136,15 @@ module Sequel
             ds.quote_schema_table_append(sql, db_type)
           end
         end
+
+        # Allow automatic parameterization if all values support it.
+        def sequel_auto_param_type(ds)
+          if db_type && all?{|v| nil == v || ds.send(:auto_param_type, v)}
+            s = String.new << "::"
+            ds.quote_schema_table_append(s, db_type)
+            s
+          end
+        end
       end
 
       # Class for row-valued/composite types that are treated as hashes.
@@ -208,6 +217,15 @@ module Sequel
             ds.quote_schema_table_append(sql, db_type)
           end
         end
+
+        # Allow automatic parameterization if all values support it.
+        def sequel_auto_param_type(ds)
+          if db_type && all?{|_,v| nil == v || ds.send(:auto_param_type, v)}
+            s = String.new << "::"
+            ds.quote_schema_table_append(s, db_type)
+            s
+          end
+        end
       end
 
       ROW_TYPE_CLASSES = [HashRow, ArrayRow].freeze
@@ -519,26 +537,9 @@ module Sequel
 
         private
 
-        # Format composite types used in bound variable arrays.
-        def bound_variable_array(arg)
-          case arg
-          when ArrayRow
-            "\"(#{arg.map{|v| bound_variable_array(v) if v}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
-          when HashRow
-            arg.check_columns!
-            "\"(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
-          else
-            super
-          end
-        end
-
         # Make the column type detection handle registered row types.
-        def schema_column_type(db_type)
-          if type = @row_schema_types[db_type]
-            type
-          else
-            super
-          end
+        def schema_composite_type(db_type)
+          @row_schema_types[db_type] || super
         end
       end
     end

data/lib/sequel/extensions/pg_timestamptz.rb

@@ -1,20 +1,35 @@
 # frozen-string-literal: true
 #
 # The pg_timestamptz extension changes the default timestamp
-# type for the database to be +timestamptz+ (+timestamp with time zone+)
-# instead of +timestamp+ (+timestamp without time zone+).  This is
+# type for the database to be +timestamptz+ (<tt>timestamp with time zone</tt>)
+# instead of +timestamp+ (<tt>timestamp without time zone</tt>).  This is
 # recommended if you are dealing with multiple timezones in your application.
+#
+# If you are using the auto_cast_date_and_time extension, the pg_timestamptz
+# extension will automatically cast Time and DateTime values to
+# <tt>TIMESTAMP WITH TIME ZONE</tt> instead of +TIMESTAMP+.
 # 
 # To load the extension into the database:
 #
 #   DB.extension :pg_timestamptz
 #
-# Related module: Sequel::Postgres::Timestamptz
+# To load the extension into individual datasets:
+#
+#   ds = ds.extension(:pg_timestamptz)
+#
+# Note that the loading into individual datasets only affects the integration
+# with the auto_cast_date_and_time extension.
+#
+# Related modules: Sequel::Postgres::Timestamptz, Sequel::Postgres::TimestamptzDatasetMethods
 
 #
 module Sequel
   module Postgres
     module Timestamptz
+      def self.extended(db)
+        db.extend_datasets(TimestamptzDatasetMethods)
+      end
+
       private
 
       # Use timestamptz by default for generic timestamp value.
@@ -22,7 +37,16 @@ module Sequel
         :timestamptz
       end
     end
+
+    module TimestamptzDatasetMethods
+      private
+
+      def literal_datetime_timestamp_cast
+        'TIMESTAMP WITH TIME ZONE '
+      end
+    end
   end
 
+  Dataset.register_extension(:pg_timestamptz, Postgres::TimestamptzDatasetMethods)
   Database.register_extension(:pg_timestamptz, Postgres::Timestamptz)
 end

data/lib/sequel/extensions/round_timestamps.rb

@@ -35,7 +35,7 @@ module Sequel
 
       # Round Sequel::SQLTime values before literalizing
       def literal_sqltime(v)
-        super(v.round(timestamp_precision))
+        super(v.round(sqltime_precision))
       end
 
       # Round Time values before literalizing

data/lib/sequel/extensions/schema_caching.rb

@@ -52,7 +52,7 @@ module Sequel
     # Dump the cached schema to the filename given in Marshal format.
     def dump_schema_cache(file)
       sch = {}
-      @schemas.each do |k,v|
+      @schemas.sort.each do |k,v|
         sch[k] = v.map do |c, h|
           h = Hash[h]
           h.delete(:callable_default)