sequel 5.101.0 → 5.104.0

data/lib/sequel/dataset/prepared_statements.rb

@@ -54,7 +54,7 @@ module Sequel
 
       # Set the bind arguments based on the hash and call super.
       def call(bind_vars=OPTS, &block)
-        sql = prepared_sql
+        sql = prepared_sql.freeze
         prepared_args.freeze
         ps = bind(bind_vars)
         ps.clone(:bind_arguments=>ps.map_to_prepared_args(ps.opts[:bind_vars]), :sql=>sql, :prepared_sql=>sql).run(&block)
@@ -223,7 +223,7 @@ module Sequel
       # with the prepared SQL, to ensure the prepared_sql_type is respected.
       def force_prepared_sql
         if prepared_sql_type != prepared_type
-          with_sql(prepared_sql)
+          with_sql(prepared_sql.freeze)
         else
           self
         end
@@ -287,7 +287,7 @@ module Sequel
 
       def run(&block)
         if @opts[:prepared_sql_frags]
-          sql = literal(Sequel::SQL::PlaceholderLiteralString.new(@opts[:prepared_sql_frags], @opts[:bind_arguments], false))
+          sql = literal(Sequel::SQL::PlaceholderLiteralString.new(@opts[:prepared_sql_frags], @opts[:bind_arguments], false)).freeze
           clone(:prepared_sql_frags=>nil, :sql=>sql, :prepared_sql=>sql).run(&block)
         else
           super
@@ -320,6 +320,9 @@ module Sequel
         end
 
         prepared_args.freeze
+        frags.freeze
+        frags.each(&:freeze)
+        prepared_sql.freeze
         clone(:prepared_sql_frags=>frags, :prepared_sql=>prepared_sql, :sql=>prepared_sql)
       end
 
@@ -409,7 +412,7 @@ module Sequel
         ps = ps.with_extend(EmulatePreparedStatementMethods)
         ps.send(:emulated_prepared_statement, type, name, values)
       else
-        sql = ps.prepared_sql
+        sql = ps.prepared_sql.freeze
         ps.prepared_args.freeze
         ps.clone(:prepared_sql=>sql, :sql=>sql)
       end

data/lib/sequel/dataset/query.rb

@@ -1301,7 +1301,7 @@ module Sequel
     # * truncate (if a TRUNCATE statement, with no arguments)
     def with_sql(sql, *args)
       if sql.is_a?(Symbol)
-        sql = public_send(sql, *args)
+        sql = public_send(sql, *args).freeze
       else
         sql = SQL::PlaceholderLiteralString.new(sql, args) unless args.empty?
       end
@@ -1474,7 +1474,10 @@ module Sequel
     def default_join_table_qualification
       :symbol
     end
-    
+
+    PAREN_WRAPPER = ["(".freeze, ")".freeze].freeze
+    private_constant :PAREN_WRAPPER
+
     # SQL expression object based on the expr type.  See +where+.
     def filter_expr(expr = nil, &block)
       expr = nil if expr == EMPTY_ARRAY
@@ -1495,7 +1498,7 @@ module Sequel
           raise Error, "Invalid filter expression: #{expr.inspect}"
         end
       when LiteralString
-        LiteralString.new("(#{expr})")
+        SQL::PlaceholderLiteralString.new(PAREN_WRAPPER, [expr])
       when Numeric, SQL::NumericExpression, SQL::StringExpression, Proc, String, Set
         raise Error, "Invalid filter expression: #{expr.inspect}"
       when TrueClass, FalseClass

data/lib/sequel/dataset/sql.rb

@@ -53,7 +53,7 @@ module Sequel
       when String
         case v
         when LiteralString
-          sql << v
+          literal_literal_string_append(sql, v)
         when SQL::Blob
           literal_blob_append(sql, v)
         else
@@ -1424,6 +1424,11 @@ module Sequel
       v.to_s
     end
 
+    # Append string to SQL string.
+    def literal_literal_string_append(sql, v)
+      sql << v
+    end
+
     # SQL fragment for nil
     def literal_nil
       "NULL"

data/lib/sequel/extensions/connection_checkout_event_callback.rb

@@ -0,0 +1,151 @@
+# frozen-string-literal: true
+#
+# The connection_checkout_event_callback extension modifies a database's
+# connection pool to allow for a checkout event callback. This callback is
+# called with the following arguments:
+#
+# :immediately_available :: Connection immediately available and returned
+# :not_immediately_available :: Connection not immediately available
+# :new_connection :: New connection created and returned
+# Float :: Number of seconds waiting to acquire a connection
+#
+# This is a low-level extension that allows for building telemetry
+# information. It doesn't implement any telemetry reporting itself. The
+# main reason for recording this information is to use it to determine the
+# appropriate size for the connection pool. Having too large a connection
+# pool can waste resources, while having too small a connection pool can
+# result in substantial time to check out a connection. In general, you
+# want to use as small a pool as possible while keeping the time to
+# checkout a connection low.
+#
+# To use the connection checkout event callback, you must first load the
+# extension:
+#
+#   DB.extension(:connection_checkout_event_callback)
+#
+# By default, an empty proc is used as the callback so that loading the
+# support doesn't break anything. If you are using the extension, you
+# should set the callback at some point during application startup:
+#
+#   DB.pool.on_checkout_event = proc do |event|
+#     # ...
+#   end
+#
+# When using the sharded connection pool, the callback is also
+# passed a second argument, the requested server shard (generally a
+# symbol), allowing for collection of per-shard telemetry:
+#
+#   DB.pool.on_checkout_event = proc do |event, server|
+#     # ...
+#   end
+#
+# Note that the callback may be called currently by multiple threads.
+# You should use some form of concurrency control inside the callback,
+# such as a mutex or queue.
+#
+# Below is a brief example of usage to determine the percentage of
+# connection requests where a connection was immediately available:
+#
+#   mutex = Mutex.new
+#   total = immediates = 0
+#
+#   DB.pool.on_checkout_event = proc do |event|
+#     case event
+#     when :immediately_available
+#       mutex.synchronize do
+#         total += 1
+#         immediates += 1
+#       end
+#     when :not_immediately_available
+#       mutex.synchronize do
+#         total += 1
+#       end
+#     end
+#   end
+#
+#   immediate_percentage = lambda do
+#     mutex.synchronize do
+#       100.0 * immediates / total
+#     end
+#   end
+#   
+# Note that this extension only works with the timed_queue
+# and sharded_timed_queue connection pools (the default
+# connection pools when using Ruby 3.2+).
+#
+# Related modules: Sequel::ConnectionCheckoutEventCallbacks::TimedQueue,
+# Sequel::ConnectionCheckoutEventCallbacks::ShardedTimedQueue
+
+#
+module Sequel
+  module ConnectionCheckoutEventCallbacks
+    module TimedQueue
+      # The callback that is called with connection checkout events.
+      attr_accessor :on_checkout_event
+
+      private
+
+      def available
+        conn = super
+        @on_checkout_event.call(conn ? :immediately_available : :not_immediately_available)
+        conn
+      end
+
+      def try_make_new
+        conn = super
+        @on_checkout_event.call(:new_connection) if conn
+        conn
+      end
+
+      def wait_until_available
+        timer = Sequel.start_timer
+        conn = super
+        @on_checkout_event.call(Sequel.elapsed_seconds_since(timer))
+        conn
+      end
+    end
+
+    module ShardedTimedQueue
+      # The callback that is called with connection checkout events.
+      attr_accessor :on_checkout_event
+
+      private
+
+      def available(queue, server)
+        conn = super
+        @on_checkout_event.call(conn ? :immediately_available : :not_immediately_available, server)
+        conn
+      end
+
+      def try_make_new(server)
+        conn = super
+        @on_checkout_event.call(:new_connection, server) if conn
+        conn
+      end
+
+      def wait_until_available(queue, server)
+        timer = Sequel.start_timer
+        conn = super
+        @on_checkout_event.call(Sequel.elapsed_seconds_since(timer), server)
+        conn
+      end
+    end
+  end
+
+  default_callback = proc{}
+
+  Database.register_extension(:connection_checkout_event_callback) do |db|
+    pool = db.pool
+
+    case pool.pool_type
+    when :timed_queue
+      db.pool.extend(ConnectionCheckoutEventCallbacks::TimedQueue)
+    when :sharded_timed_queue
+      db.pool.extend(ConnectionCheckoutEventCallbacks::ShardedTimedQueue)
+    else
+      raise Error, "the connection_checkout_event_callback extension is only supported when using a timed_queue connection pool"
+    end
+
+    pool.on_checkout_event ||= default_callback
+  end
+end

data/lib/sequel/extensions/connection_expiration.rb

@@ -91,7 +91,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

@@ -118,7 +118,7 @@ module Sequel
                 sync{@allocated.delete(Sequel.current)}
               end
 
-              disconnect_connection(conn)
+              disconnect_acquired_connection(conn, *a)
               redo if valid == false
             end
           end

data/lib/sequel/extensions/dataset_run.rb

@@ -30,9 +30,9 @@ module Sequel
     #   # GRANT SELECT ON "table" TO "user"
     def run
       if server = @opts[:server]
-        db.run(sql, :server=>server)
+        db.run(sql.freeze, :server=>server)
       else
-        db.run(sql)
+        db.run(sql.freeze)
       end
     end
   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/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/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
 
@@ -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
 

data/lib/sequel/extensions/pg_enum.rb

@@ -127,7 +127,7 @@ module Sequel
 
       # Run the SQL on the database, reparsing the enum labels after it is run.
       def _process_enum_change_sql(sql)
-        run(sql)
+        run(sql.freeze)
         parse_enum_labels
         nil
       end