sequel 5.83.0 → 5.106.0

data/lib/sequel/extensions/connection_expiration.rb

@@ -46,8 +46,10 @@ module Sequel
     # Initialize the data structures used by this extension.
     def self.extended(pool)
       case pool.pool_type
-      when :single, :sharded_single
-        raise Error, "cannot load connection_expiration extension if using single or sharded_single connection pool"
+      when :threaded, :sharded_threaded, :timed_queue, :sharded_timed_queue
+        nil
+      else
+        raise Error, "cannot load connection_expiration extension if using single or sharded_single connection pool (or other unsupported connection pool)"
       end
 
       pool.instance_exec do
@@ -55,6 +57,39 @@ module Sequel
           @connection_expiration_timestamps ||= {}
           @connection_expiration_timeout ||= 14400
           @connection_expiration_random_delay ||= 0
+
+          # Record an expiration timestamp for any connections that already
+          # exist in the pool, so that a connection opened before the extension
+          # was loaded (e.g. via Sequel.connect) will eventually be expired.
+          register = method(:register_connection_expiration_time)
+
+          case pool_type
+          when :timed_queue, :sharded_timed_queue
+            register_queued_connections = lambda do |queue|
+              conns = []
+              while conn = queue.pop(timeout: 0)
+                conns << conn
+              end
+              conns.each do |conn|
+                queue.push(register_connection_expiration_time(conn))
+              end
+            end
+          end
+
+          case pool_type
+          when :threaded
+            @available_connections.each(&register)
+            @allocated.each_value(&register)
+          when :sharded_threaded
+            @available_connections.each_value{|conns| conns.each(&register)}
+            @allocated.each_value{|threads| threads.each_value(&register)}
+          when :timed_queue
+            register_queued_connections.call(@queue)
+            @allocated.each_value(&register)
+          else # when :sharded_timed_queue
+            @queues.each_value(&register_queued_connections)
+            @allocated.each_value{|threads| threads.each_value(&register)}
+          end
         end
       end
     end
@@ -69,8 +104,12 @@ module Sequel
 
     # Record the time the connection was created.
     def make_new(*)
-      conn = super
-      @connection_expiration_timestamps[conn] = [Sequel.start_timer, @connection_expiration_timeout + (rand * @connection_expiration_random_delay)].freeze
+      register_connection_expiration_time(super)
+    end
+
+    # Record an expiration entry for a connection, returns the connection.
+    def register_connection_expiration_time(conn)
+      @connection_expiration_timestamps[conn] ||= [Sequel.start_timer, @connection_expiration_timeout + (rand * @connection_expiration_random_delay)].freeze
       conn
     end
 
@@ -91,7 +130,7 @@ module Sequel
             sync{@allocated.delete(Sequel.current)}
           end
 
-          disconnect_connection(conn)
+          disconnect_acquired_connection(conn, *a)
           redo
         end
       end

data/lib/sequel/extensions/connection_validator.rb

@@ -105,18 +105,23 @@ module Sequel
       1.times do
         if (conn = super) &&
            (timer = sync{@connection_timestamps.delete(conn)}) &&
-           Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout &&
-           !db.valid_connection?(conn)
+           Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout
 
-          case pool_type
-          when :sharded_threaded, :sharded_timed_queue
-            sync{@allocated[a.last].delete(Sequel.current)}
-          else
-            sync{@allocated.delete(Sequel.current)}
-          end
+          begin
+            valid = db.valid_connection?(conn)
+          ensure
+            unless valid
+              case pool_type
+              when :sharded_threaded, :sharded_timed_queue
+                sync{@allocated[a.last].delete(Sequel.current)}
+              else
+                sync{@allocated.delete(Sequel.current)}
+              end
 
-          disconnect_connection(conn)
-          redo
+              disconnect_acquired_connection(conn, *a)
+              redo if valid == false
+            end
+          end
         end
       end
 

data/lib/sequel/extensions/constraint_validations.rb

@@ -436,7 +436,7 @@ module Sequel
             else
               raise Error, "validates includes with a range only supports integers currently, cannot handle: #{arg.inspect}"
             end
-          elsif arg.is_a?(Array)
+          elsif arg.is_a?(Array) || arg.is_a?(Set)
             if arg.all?{|x| x.is_a?(Integer)}
               validation_type = :includes_int_array
             elsif arg.all?{|x| x.is_a?(String)}
@@ -444,9 +444,9 @@ module Sequel
             else
               raise Error, "validates includes with an array only supports strings and integers currently, cannot handle: #{arg.inspect}"
             end
-            arg = arg.join(',')
+            arg = Sequel.array_or_set_join(arg, ',')
           else
-            raise Error, "validates includes only supports arrays and ranges currently, cannot handle: #{arg.inspect}"
+            raise Error, "validates includes only supports arrays, sets, and ranges currently, cannot handle: #{arg.inspect}"
           end
         when :like, :ilike
           generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.public_send(validation_type, c, arg)})

data/lib/sequel/extensions/dataset_run.rb

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+#
+# The dataset_run extension is designed for cases where you want
+# to use dataset methods to build a query, but want to run that
+# query without returning a result.  The most common need would
+# be to easily use placeholders in an SQL string, which Database#run
+# does not support directly.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB["GRANT SELECT ON ? TO ?", :table, :user]
+#   ds = ds.extension(:dataset_run)
+#   ds.run
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:dataset_run)
+#   DB["GRANT SELECT ON ? TO ?", :table, :user].run
+#
+# Related module: Sequel::DatasetRun
+
+#
+module Sequel
+  module DatasetRun
+    # Run the dataset's SQL on the database.  Returns NULL.  This is
+    # useful when you want to run SQL without returning a result.
+    #
+    #   DB["GRANT SELECT ON ? TO ?", :table, :user].run
+    #   # GRANT SELECT ON "table" TO "user"
+    def run
+      if server = @opts[:server]
+        db.run(sql.freeze, :server=>server)
+      else
+        db.run(sql.freeze)
+      end
+    end
+  end
+
+  Dataset.register_extension(:dataset_run, DatasetRun)
+end

data/lib/sequel/extensions/date_arithmetic.rb

@@ -82,12 +82,12 @@ module Sequel
         DURATION_UNITS = [:years, :months, :days, :hours, :minutes, :seconds].freeze
         DEF_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s.freeze}).freeze
         POSTGRES_DURATION_UNITS = DURATION_UNITS.zip([:years, :months, :days, :hours, :mins, :secs].map{|s| s.to_s.freeze}).freeze
-        MYSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.upcase[0...-1]).freeze}).freeze
-        MSSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s[0...-1]).freeze}).freeze
+        MYSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.upcase[0...-1].freeze).freeze}).freeze
+        MSSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s[0...-1].freeze).freeze}).freeze
         H2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s[0...-1].freeze}).freeze
-        DERBY_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit("SQL_TSI_#{s.to_s.upcase[0...-1]}").freeze}).freeze
+        DERBY_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit("SQL_TSI_#{s.to_s.upcase[0...-1]}".freeze).freeze}).freeze
         ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map(&:freeze)).freeze
-        DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s).freeze}).freeze
+        DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.freeze).freeze}).freeze
 
         # Append the SQL fragment for the DateAdd expression to the SQL query.
         def date_add_sql_append(sql, da)
@@ -107,7 +107,7 @@ module Sequel
               placeholder = []
               vals = []
               each_valid_interval_unit(h, POSTGRES_DURATION_UNITS) do |value, sql_unit|
-                placeholder << "#{', ' unless placeholder.empty?}#{sql_unit} := "
+                placeholder << "#{', ' unless placeholder.empty?}#{sql_unit} := ".freeze
                 vals << value
               end
               interval = Sequel.function(:make_interval, Sequel.lit(placeholder, *vals)) unless vals.empty?
@@ -156,7 +156,7 @@ module Sequel
               expr = Sequel.cast_string(expr) + ' 00:00:00'
             end
             each_valid_interval_unit(h, DERBY_DURATION_UNITS) do |value, sql_unit|
-              expr = Sequel.lit(["{fn timestampadd(#{sql_unit}, ", ", timestamp(", "))}"], value, expr)
+              expr = Sequel.lit(["{fn timestampadd(#{sql_unit}, ".freeze, ", timestamp(", "))}"], value, expr)
             end
           when :oracle
             each_valid_interval_unit(h, MYSQL_DURATION_UNITS) do |value, sql_unit|

data/lib/sequel/extensions/empty_array_consider_nulls.rb

@@ -9,6 +9,13 @@
 #   DB[:test].exclude(name: [])
 #   # SELECT * FROM test WHERE (name = name)
 #
+# This works for sets in addition to arrays:
+#
+#   DB[:test].where(name: Set[])
+#   # SELECT * FROM test WHERE (name != name)
+#   DB[:test].exclude(name: Set[])
+#   # SELECT * FROM test WHERE (name = name)
+#
 # The default Sequel behavior is to ignore NULLs, as the above
 # query is not generally optimized well by databases.
 #

data/lib/sequel/extensions/eval_inspect.rb

@@ -34,6 +34,8 @@ module Sequel
         "#{obj.class}.new(#{obj.to_a.inspect})"
       when Array
         "[#{obj.map{|o| eval_inspect(o)}.join(', ')}]"
+      when Set
+        "Set[#{obj.map{|o| eval_inspect(o)}.join(', ')}]"
       when Hash
         "{#{obj.map{|k, v| "#{eval_inspect(k)} => #{eval_inspect(v)}"}.join(', ')}}"
       when Time
@@ -66,7 +68,7 @@ module Sequel
         # in the order they were defined.
         klass = self.class
         args = inspect_args.map do |arg|
-          if arg.is_a?(String) && arg =~ /\A\*/
+          if arg.is_a?(String) && arg.start_with?('*')
             # Special case string arguments starting with *, indicating that
             # they should return an array to be splatted as the remaining arguments.
             # Allow calling private methods to get inspect output.

data/lib/sequel/extensions/inflector.rb

@@ -159,7 +159,7 @@ class String
   # Example
   #   "puni_puni".dasherize #=> "puni-puni"
   def dasherize
-    gsub('_', '-')
+    tr('_', '-')
   end
 
   # Removes the module part from the expression in the string
@@ -189,7 +189,7 @@ class String
   #   "employee_salary" #=> "Employee salary"
   #   "author_id" #=> "Author"
   def humanize
-    gsub(/_id$/, "").gsub('_', " ").capitalize
+    gsub(/_id$/, "").tr('_', " ").capitalize
   end
 
   # Returns the plural form of the word in the string.

data/lib/sequel/extensions/lit_require_frozen.rb

@@ -0,0 +1,131 @@
+# frozen-string-literal: true
+#
+# The lit_require_frozen extension disallows the use of unfrozen strings
+# as literal strings in database and dataset methods. If you try to use an
+# unfrozen string as a literal string for a dataset using this extension,
+# an exception will be raised.
+#
+# While this works for all Ruby versions, it is designed for use on Ruby 3+
+# where all files are using the frozen-string-literal magic comment. In this
+# case, uninterpolated literal strings are frozen, but interpolated strings
+# are not frozen. This allows you to catch potentially dangerous code:
+#
+#   # Probably safe, no exception raised
+#   DB["SELECT * FROM t WHERE c > :v", v: user_provided_string)
+#
+#   # Potentially unsafe, raises Sequel::LitRequireFrozen::Error
+#   DB["SELECT * FROM t WHERE c > '#{user_provided_string}'"]
+#
+# The assumption made is that a frozen string is unlikely to contain unsafe
+# input, while an unfrozen string has potentially been interpolated and may
+# contain unsafe input.
+#
+# This disallows the the following cases:
+#
+# * Sequel::LiteralString instances that are unfrozen and are not based on a
+#   frozen string
+# * Sequel::SQL::PlaceholderLiteralString instances when the placeholder string
+#   is not frozen
+# * Unfrozen strings passed to Database#<< or #[] or Dataset#with_sql
+#
+# To use this extension, load it into the database:
+#
+#   DB.extension :lit_require_frozen
+#
+# It can also be loaded into individual datasets:
+#
+#  ds = DB[:t].extension(:lit_require_frozen)
+#
+# Assuming you have good test coverage, it is recommended to only load
+# this extension when testing.
+#
+# Related module: Sequel::LitRequireFrozen
+
+#
+module Sequel
+  class LiteralString
+    # The string used when creating the literal string (first argument to
+    # Sequel::LiteralString.new). This may be nil if no string was provided,
+    # or if the litral string was created before this extension was required.
+    attr_reader :source
+
+    def initialize(*a)
+      @source = a.first
+      super
+    end
+    # :nocov:
+    ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
+    # :nocov:
+  end
+
+  module LitRequireFrozen
+    # Error class raised for using unfrozen literal string.
+    class Error < Sequel::Error
+    end
+
+    module DatabaseMethods
+      def self.extended(db)
+        db.extend_datasets(DatasetMethods)
+      end
+
+      # Check given SQL is frozen before running it.
+      def run(sql, opts=OPTS)
+        @default_dataset.with_sql(sql)
+        super
+      end
+    end
+
+    module DatasetMethods
+      # Check given SQL is not an unfrozen string.
+      def with_sql(sql, *args)
+        _check_unfrozen_literal_string(sql)
+        super
+      end
+
+      # Check that placeholder string is frozen (or all entries
+      # in placeholder array are frozen).
+      def placeholder_literal_string_sql_append(sql, pls)
+        str = pls.str
+
+        if str.is_a?(Array)
+          str.each do |s|
+            _check_unfrozen_literal_string(s)
+          end
+        else
+          _check_unfrozen_literal_string(str)
+        end
+
+        super
+      end
+
+      private
+
+      # Base method that other methods used to check for whether a string should be allowed
+      # as literal SQL. Allows non-strings as well as frozen strings.
+      def _check_unfrozen_literal_string(str)
+        return if !str.is_a?(String) || str.frozen?
+
+        if str.is_a?(LiteralString)
+          _check_unfrozen_literal_string(str.source)
+        else
+          raise Error, "cannot treat unfrozen string as literal SQL: #{str.inspect}"
+        end
+      end
+
+      # Check literal strings appended to SQL.
+      def literal_literal_string_append(sql, v)
+        _check_unfrozen_literal_string(v)
+        super
+      end
+
+      # Check static SQL is not frozen.
+      def static_sql(sql)
+        _check_unfrozen_literal_string(sql)
+        super
+      end
+    end
+  end
+
+  Dataset.register_extension(:lit_require_frozen, LitRequireFrozen::DatasetMethods)
+  Database.register_extension(:lit_require_frozen, LitRequireFrozen::DatabaseMethods)
+end

data/lib/sequel/extensions/looser_typecasting.rb

@@ -37,18 +37,11 @@ module Sequel
       value.to_s
     end
 
-    if RUBY_VERSION >= '2.4'
-      def _typecast_value_string_to_decimal(value)
-        BigDecimal(value)
-      rescue
-        BigDecimal('0.0')
-      end
-    else
-      # :nocov:
-      def _typecast_value_string_to_decimal(value)
-        BigDecimal(value)
-      end
-      # :nocov:
+    # Typecast invalid BigDecimal to 0.0.
+    def _typecast_value_string_to_decimal(value)
+      BigDecimal(value)
+    rescue
+      BigDecimal('0.0')
     end
   end
 

data/lib/sequel/extensions/migration.rb

@@ -186,22 +186,19 @@ module Sequel
     # and returns a new block that reverses the actions taken by
     # the given block.
     def reverse(&block)
-      begin
-        instance_exec(&block)
-      rescue
-        just_raise = true
-      end
-      if just_raise
-        Proc.new{raise Sequel::Error, "irreversible migration method used in #{block.source_location.first}, you may need to write your own down method"}
-      else
-        actions = @actions.reverse
-        Proc.new do
-          actions.each do |a|
-            pr = a.last.is_a?(Proc) ? a.pop : nil
-            # Allow calling private methods as the reversing methods are private
-            send(*a, &pr)
-          end
-        end
+      instance_exec(&block)
+    rescue NoMethodError => e
+      Proc.new{raise Sequel::Error, "irreversible migration method \"#{e.name}\" used in #{block.source_location.first}, you may need to write your own down method"}
+    rescue => e
+      Proc.new{raise Sequel::Error, "unable to reverse migration due to #{e.class} in #{block.source_location.first}, you may need to write your own down method"}
+    else
+      actions = @actions.reverse
+      Proc.new do
+       actions.each do |a|
+        pr = a.last.is_a?(Proc) ? a.pop : nil
+        # Allow calling private methods as the reversing methods are private
+        send(*a, &pr)
+       end
       end
     end
 
@@ -223,7 +220,7 @@ module Sequel
       @actions << [:drop_join_table, *args]
     end
 
-    def create_table(name, opts=OPTS)
+    def create_table(name, opts=OPTS, &_)
       @actions << [:drop_table, name, opts]
     end
 
@@ -270,7 +267,7 @@ module Sequel
     end
 
     def add_primary_key(*args)
-      raise if args.first.is_a?(Array)
+      super if args.first.is_a?(Array)
       @actions << [:drop_column, args.first]
     end
 
@@ -287,6 +284,10 @@ module Sequel
     def set_column_allow_null(name, allow_null=true)
       @actions << [:set_column_allow_null, name, !allow_null]
     end
+
+    def set_column_not_null(name)
+      @actions << [:set_column_allow_null, name]
+    end
   end
 
   # The preferred method for writing Sequel migrations, using a DSL:
@@ -371,7 +372,7 @@ module Sequel
   #
   # Part of the +migration+ extension.
   class Migrator
-    MIGRATION_FILE_PATTERN = /\A(\d+)_.+\.rb\z/i.freeze
+    MIGRATION_FILE_PATTERN = /\A(\d+)_(.+)\.rb\z/i.freeze
 
     # Mutex used around migration file loading
     MUTEX = Mutex.new
@@ -791,7 +792,23 @@ module Sequel
         next unless MIGRATION_FILE_PATTERN.match(file)
         files << File.join(directory, file)
       end
-      files.sort_by{|f| MIGRATION_FILE_PATTERN.match(File.basename(f))[1].to_i}
+      files.sort! do |a, b|
+        a_ver, a_name = split_migration_filename(a)
+        b_ver, b_name = split_migration_filename(b)
+        x = a_ver <=> b_ver
+        if x.zero?
+          x = a_name <=> b_name
+        end
+        x
+      end
+      files
+    end
+
+    # Return an integer and name (without extension) for the given path.
+    def split_migration_filename(path)
+      version, name = MIGRATION_FILE_PATTERN.match(File.basename(path)).captures
+      version = version.to_i
+      [version, name]
     end
     
     # Returns tuples of migration, filename, and direction
@@ -825,7 +842,7 @@ module Sequel
         begin
           db.create_table(table){String c, :primary_key=>true}
         rescue Sequel::DatabaseError => e
-          if db.database_type == :mysql && e.message =~ /max key length/
+          if db.database_type == :mysql && e.message.include?('max key length')
             # Handle case where MySQL is used with utf8mb4 charset default, which
             # only allows a maximum length of about 190 characters for string
             # primary keys due to InnoDB limitations.

data/lib/sequel/extensions/null_dataset.rb

@@ -63,12 +63,12 @@ module Sequel
       end
 
       # Return self without sending a database query, never yielding.
-      def each
+      def each(&_)
         self
       end
 
       # Return nil without sending a database query, never yielding.
-      def fetch_rows(sql)
+      def fetch_rows(sql, &_)
         nil
       end
 

data/lib/sequel/extensions/pg_array_ops.rb

@@ -56,6 +56,13 @@
 #   ia.join(':', ' ')  # array_to_string(int_array_column, ':', ' ')
 #   ia.unnest          # unnest(int_array_column)
 #   ia.unnest(:b)      # unnest(int_array_column, b)
+#
+# On PostgreSQL 18+, the following are supported:
+#
+#   ia.sort                # array_sort(int_array_column)
+#   ia.sort(desc: true)    # array_sort(int_array_column, true)
+#   ia.sort(nulls: :first) # array_sort(int_array_column, false, true)
+#   ia.reverse             # array_reverse(int_array_column)
 # 
 # See the PostgreSQL array function and operator documentation for more
 # details on what these functions and operators do.
@@ -217,6 +224,40 @@ module Sequel
         ArrayOp.new(function(:array_replace, element, replacement))
       end
 
+      # Call the array_reverse method:
+      #
+      #   array_op.reverse # array_reverse(array)
+      def reverse
+        function(:array_reverse)
+      end
+      
+      # Call the array_sort method. Options:
+      #
+      # :desc :: Sort in descending order instead of ascending order.
+      # :nulls :: If sorting in ascending order and value is :first, include NULL
+      #           values before non-NULL values. If sorting in descending order and
+      #           value is :last, include non-NULL values before NULL values.
+      #
+      #   array_op.sort                           # array_sort(array)
+      #   array_op.sort(desc: true)               # array_sort(array, true)
+      #   array_op.sort(nulls: :first)            # array_sort(array, false, true)
+      #   array_op.sort(desc: true, nulls: :last) # array_sort(array, true, false)
+      def sort(opts=OPTS)
+        desc = opts[:desc]
+        nulls = opts[:nulls]
+        if desc
+          if nulls == :last
+            function(:array_sort, true, false)
+          else
+            function(:array_sort, true)
+          end
+        elsif nulls == :first
+          function(:array_sort, false, true)
+        else
+          function(:array_sort)
+        end
+      end
+      
       # Call the array_to_string method:
       #
       #   array_op.join           # array_to_string(array, '')

data/lib/sequel/extensions/pg_auto_parameterize.rb

@@ -348,6 +348,8 @@ module Sequel
         # automatically parameterized.
         def auto_param_type(v)
           case v
+          when Symbol
+            false
           when String
             case v
             when LiteralString
@@ -394,7 +396,7 @@ module Sequel
         # there can be more than one parameter per column, so this doesn't prevent going
         # over the limit, though it does make it less likely.
         def default_import_slice
-          40
+          @opts[:no_auto_parameterize] ? super : 40
         end
 
         # Handle parameterization of multi_insert_sql
@@ -406,9 +408,9 @@ module Sequel
           end
         end
 
-        # Whether the given argument is an array of integers or NULL values, recursively.
+        # Whether the given argument is an array or set of integers or NULL values, recursively.
         def _integer_array?(v)
-          Array === v && v.all?{|x| nil == x || Integer === x}
+          (Array === v || Set === v) && v.all?{|x| nil == x || Integer === x}
         end
 
         # Create the bound variable string that will be used for the IN (int, ...) to = ANY($)
@@ -463,6 +465,11 @@ module Sequel
           @opts[:no_auto_parameterize] ? super : QueryString.new
         end
 
+        # A mutable string used as the prefix when explaining a query.
+        def explain_sql_string_origin(opts)
+          @opts[:no_auto_parameterize] ? super : (QueryString.new << super)
+        end
+
         # If subquery uses with_sql with a method name symbol, get the dataset
         # with_sql was called on, and use that as the subquery, recording the
         # arguments to with_sql that will be used to calculate the sql.