sequel 5.45.0 → 5.77.0

data/lib/sequel/extensions/pg_auto_parameterize_in_array.rb

@@ -0,0 +1,110 @@
+# frozen-string-literal: true
+#
+# The pg_auto_parameterize_in_array extension builds on the pg_auto_parameterize
+# extension, adding support for handling additional types when converting from
+# IN to = ANY and NOT IN to != ALL:
+#
+#   DB[:table].where(column: [1.0, 2.0, ...])
+#   # Without extension: column IN ($1::numeric, $2:numeric, ...) # bound variables: 1.0, 2.0, ...
+#   # With extension:    column = ANY($1::numeric[]) # bound variables: [1.0, 2.0, ...]
+#
+# This prevents the use of an unbounded number of bound variables based on the
+# size of the array, as well as using different SQL for different array sizes.
+#
+# The following types are supported when doing the conversions, with the database
+# type used:
+#
+# Float :: if any are infinite or NaN, double precision, otherwise numeric
+# BigDecimal :: numeric
+# Date :: date
+# Time :: timestamp (or timestamptz if pg_timestamptz extension is used)
+# DateTime :: timestamp (or timestamptz if pg_timestamptz extension is used)
+# Sequel::SQLTime :: time
+# Sequel::SQL::Blob :: bytea
+# 
+# String values are also supported using the +text+ type, but only if the 
+# +:treat_string_list_as_text_array+ Database option is used. This is because
+# treating strings as text can break programs, since the type for
+# literal strings in PostgreSQL is +unknown+, not +text+.
+#
+# The conversion is only done for single dimensional arrays that have more
+# than two elements, where all elements are of the same class (other than
+# nil values).
+#
+# Related module: Sequel::Postgres::AutoParameterizeInArray
+
+module Sequel
+  module Postgres
+    # Enable automatically parameterizing queries.
+    module AutoParameterizeInArray
+      # Transform column IN (...) expressions into column = ANY($)
+      # and column NOT IN (...) expressions into column != ALL($)
+      # using an array bound variable for the ANY/ALL argument,
+      # if all values inside the predicate are of the same type and
+      # the type is handled by the extension.
+      # This is the same optimization PostgreSQL performs internally,
+      # but this reduces the number of bound variables.
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :IN, :"NOT IN"
+          l, r = args
+          if auto_param?(sql) && (type = _bound_variable_type_for_array(r))
+            if op == :IN 
+              op = :"="
+              func = :ANY
+            else
+              op = :!=
+              func = :ALL
+            end
+            args = [l, Sequel.function(func, Sequel.pg_array(r, type))]
+          end
+        end
+
+        super
+      end
+
+      private
+
+      # The bound variable type string to use for the bound variable array.
+      # Returns nil if a bound variable should not be used for the array.
+      def _bound_variable_type_for_array(r)
+        return unless Array === r && r.size > 1
+        classes = r.map(&:class)
+        classes.uniq!
+        classes.delete(NilClass)
+        return unless classes.size == 1
+
+        klass = classes[0]
+        if klass == Integer
+          # This branch is not taken on Ruby <2.4, because of the Fixnum/Bignum split.
+          # However, that causes no problems as pg_auto_parameterize handles integer
+          # arrays natively (though the SQL used is different)
+          "int8"
+        elsif klass == String
+          "text" if db.typecast_value(:boolean, db.opts[:treat_string_list_as_text_array])
+        elsif klass == BigDecimal
+          "numeric"
+        elsif klass == Date
+          "date"
+        elsif klass == Time
+          @db.cast_type_literal(Time)
+        elsif klass == Float
+          # PostgreSQL treats literal floats as numeric, not double precision
+          # But older versions of PostgreSQL don't handle Infinity/NaN in numeric
+          r.all?{|v| v.nil? || v.finite?} ? "numeric" : "double precision"
+        elsif klass == Sequel::SQLTime
+          "time"
+        elsif klass == DateTime
+          @db.cast_type_literal(DateTime)
+        elsif klass == Sequel::SQL::Blob
+          "bytea"
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:pg_auto_parameterize_in_array) do |db|
+    db.extension(:pg_array, :pg_auto_parameterize)
+    db.extend_datasets(Postgres::AutoParameterizeInArray)
+  end
+end

data/lib/sequel/extensions/pg_enum.rb

@@ -166,8 +166,7 @@ module Sequel
       def schema_post_process(_)
         super.each do |_, s|
           oid = s[:oid]
-          if values = Sequel.synchronize{@enum_labels[oid]}
-            s[:type] = :enum
+          if s[:type] == :enum && (values = Sequel.synchronize{@enum_labels[oid]})
             s[:enum_values] = values
           end
         end

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

@@ -76,7 +76,7 @@
 #
 # This extension integrates with the pg_array extension.  If you plan
 # to use arrays of hstore types, load the pg_array extension before the
-# pg_interval extension:
+# pg_hstore extension:
 #
 #   DB.extension :pg_array, :pg_hstore
 #
@@ -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_hstore_ops.rb

@@ -62,6 +62,19 @@
 #   # Delete a key
 #   DB[:tab].update(h: Sequel.hstore_op(:h).delete('k1'))
 #  
+# On PostgreSQL 14+, The hstore <tt>[]</tt> method will use subscripts instead of being
+# the same as +get+, if the value being wrapped is an identifer:
+#
+#   Sequel.hstore_op(:hstore_column)['a']    # hstore_column['a']
+#   Sequel.hstore_op(Sequel[:h][:s])['a']      # h.s['a']
+#
+# This support allows you to use hstore subscripts in UPDATE statements to update only
+# part of a column:
+#
+#   h = Sequel.hstore_op(:h)
+#   DB[:t].update(h['key1'] => 'val1', h['key2'] => 'val2')
+#   #  UPDATE "t" SET "h"['key1'] = 'val1', "h"['key2'] = 'val2'
+#
 # See the PostgreSQL hstore function and operator documentation for more
 # details on what these functions and operators do.
 #
@@ -114,10 +127,15 @@ module Sequel
       #
       #   hstore_op['a'] # (hstore -> 'a')
       def [](key)
-        v = Sequel::SQL::PlaceholderLiteralString.new(LOOKUP, [value, wrap_input_array(key)])
         if key.is_a?(Array) || (defined?(Sequel::Postgres::PGArray) && key.is_a?(Sequel::Postgres::PGArray)) || (defined?(Sequel::Postgres::ArrayOp) && key.is_a?(Sequel::Postgres::ArrayOp))
-          wrap_output_array(v)
+          wrap_output_array(Sequel::SQL::PlaceholderLiteralString.new(LOOKUP, [value, wrap_input_array(key)]))
         else
+          v = case @value
+          when Symbol, SQL::Identifier, SQL::QualifiedIdentifier
+            HStoreSubscriptOp.new(self, key)
+          else
+            Sequel::SQL::PlaceholderLiteralString.new(LOOKUP, [value, key])
+          end
           Sequel::SQL::StringExpression.new(:NOOP, v)
         end
       end
@@ -304,6 +322,38 @@ module Sequel
       end
     end
 
+    # Represents hstore subscripts. This is abstracted because the
+    # subscript support depends on the database version.
+    class HStoreSubscriptOp < SQL::Expression
+      SUBSCRIPT = ["".freeze, "[".freeze, "]".freeze].freeze
+
+      # The expression being subscripted
+      attr_reader :expression
+
+      # The subscript to use
+      attr_reader :sub
+
+      # Set the expression and subscript to the given arguments
+      def initialize(expression, sub)
+        @expression = expression
+        @sub = sub
+        freeze
+      end
+
+      # Use subscripts instead of -> operator on PostgreSQL 14+
+      def to_s_append(ds, sql)
+        server_version = ds.db.server_version
+        frag = server_version && server_version >= 140000 ? SUBSCRIPT : HStoreOp::LOOKUP
+        ds.literal_append(sql, Sequel::SQL::PlaceholderLiteralString.new(frag, [@expression, @sub]))
+      end
+
+      # Support transforming of hstore subscripts
+      def sequel_ast_transform(transformer)
+        self.class.new(transformer.call(@expression), transformer.call(@sub))
+      end
+    end
+
+
     module HStoreOpMethods
       # Wrap the receiver in an HStoreOp so you can easily use the PostgreSQL
       # hstore functions and operators with it.
@@ -356,7 +406,7 @@ end
 if defined?(Sequel::CoreRefinements)
   module Sequel::CoreRefinements
     refine Symbol do
-      include Sequel::Postgres::HStoreOpMethods
+      send INCLUDE_METH, Sequel::Postgres::HStoreOpMethods
     end
   end
 end

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

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

data/lib/sequel/extensions/pg_interval.rb

@@ -32,6 +32,7 @@
 #
 # Related module: Sequel::Postgres::IntervalDatabaseMethods
 
+require 'active_support'
 require 'active_support/duration'
 
 # :nocov:
@@ -162,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|
@@ -196,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
@@ -206,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)
@@ -387,11 +397,9 @@ module Sequel
       # argument is true), or a String, Numeric, true, false, or nil
       # if the json library used supports that.
       def _parse_json(s)
-        begin
-          Sequel.parse_json(s)
-        rescue Sequel.json_parser_error_class => e
-          raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
-        end
+        Sequel.parse_json(s)
+      rescue Sequel.json_parser_error_class => e
+        raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
       end
 
       # Wrap the parsed JSON value in the appropriate JSON wrapper class.
@@ -426,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