sequel 5.62.0 → 5.64.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df5fea5cf2d6dae7a5721c549c89a190df5a1cf79f2e7d48921dcdaeae398839
-  data.tar.gz: e1155c60bb4c2845a96cddf0a7d5498358f1cba826fdc9d7f00754a017b4310f
+  metadata.gz: 1971882f6efac487f21b4b5fb74695b757f2e129c14d82ffdca062cd5bc9d58f
+  data.tar.gz: ca4d9df4e18bd2806ad0a288856cb87f270f702a73f8de0ebea3934776d4304c
 SHA512:
-  metadata.gz: 8e52498bbcc1c2d472592b213be8e6e508f5881de5c1ae0579b426211aa448960e06bdb297f43eb26ee3024923f78e54bb17f9a886710c3ffe60f0c134746029
-  data.tar.gz: 0d5ae732cde0ad90a4c331f40628628e346386c483267173eb50eaad067d7de14ba6ff3c83f598d7440a6fcc752e4439cf1856706489cc3d3b7cffaf5b6d8de8
+  metadata.gz: abdd0fbcb5da74256493a8cfb7ff32f9247d8b021096344d3d072d2d5981fec557ed222df11da3db12abae7318c43c09b9bb2c63795816244aea76425f4106ba
+  data.tar.gz: 7b37c7c8cdc9172baf273ee80b328fa79bd6694a070ef81220e31bbaa20bcb0dc90a137b5cccd4c0326a7b99f17dd57591deab375dbaf61881bac3536b4eeb12

data/CHANGELOG

@@ -1,3 +1,27 @@
+=== 5.64.0 (2023-01-01)
+
+* Make :db_type column schema entries on SQLAnywhere include precision/scale information (jeremyevans)
+
+* Include :min_value and :max_value schema entries for decimal/numeric columns on most databases (rolftimmermans, jeremyevans) (#1975)
+
+* Support :graph_use_association_block association option to make eager_graph use the association block (jeremyevans)
+
+* Make many_through_many and many_through_one associations support eager_graph callbacks (jeremyevans)
+
+=== 5.63.0 (2022-12-01)
+
+* Make validates_associated plugin avoid database type errors for non-integer association keys (jeremyevans) (#1968)
+
+* Make tactical_eager_loading plugin work better with table inheritance plugins (rolftimmermans, jeremyevans) (#1962)
+
+* Add support for pool_class: :timed_queue on Ruby 3.2+, using a Queue for available connections (jeremyevans)
+
+* Allow :pool_class Database option to be specified as a string to more easily choose a different pool type (jeremyevans)
+
+* Use compare_by_identity hashes for Thread-keyed hashes in threaded connection pools (jeremyevans)
+
+* Skip use of JRuby workaround on JRuby 9.3.9.0+ in named_timezones extension as JRuby fixed the related bug (jeremyevans)
+
 === 5.62.0 (2022-11-01)
 
 * Add back the pg_auto_parameterize extension for automatically using bound variables when using postgres adapter with pg driver (jeremyevans)

data/doc/association_basics.rdoc

@@ -1498,6 +1498,36 @@ as the qualifiers may not match the aliases automatically used by eager_graph.
 This should contain unqualified identifiers, and eager_graph will automatically
 qualify them with the appropriate alias.
 
+==== :graph_use_association_block
+
+Setting this to true makes eager_graph apply the association block to the
+associated dataset before graphing the associated dataset into the receiver.
+In most cases when this option is used and the association has a block, the
+dataset returned by eager_graph will contain a JOIN to a subquery.
+
+By default (when this option is not used), the association block will be ignored
+when using eager_graph:
+
+  Artist.one_to_many :tracks do |ds|
+    ds.where(foo: 3)
+  end
+  Artist.eager_graph(:tracks)
+  # SELECT albums.id, tracks.id AS tracks_id, tracks.album_id
+  # FROM albums
+  # LEFT OUTER JOIN tracks
+  # ON (tracks.album_id = albums.id)
+
+When this option is used, the block will be respected:
+
+  Artist.one_to_many :tracks, graph_use_association_block: true do |ds|
+    ds.where(foo: 3)
+  end
+  Artist.eager_graph(:tracks)
+  # SELECT albums.id, tracks.id AS tracks_id, tracks.album_id
+  # FROM albums
+  # LEFT OUTER JOIN (SELECT * FROM tracks WHERE (foo = 3)) AS tracks
+  # ON (tracks.album_id = albums.id)
+
 ==== :graph_join_table_conditions [+many_to_many+, +one_through_one+]
 
 The additional conditions to use on the SQL join for the join table when

data/doc/release_notes/5.63.0.txt

@@ -0,0 +1,33 @@
+= New Features
+
+* On Ruby 3.2, the pool_class: :timed_queue Database option can now
+  be used to use an alternative connection pool that stores
+  connections in a queue, and uses the new Queue#pop :timeout option
+  in Ruby 3.2 to implement the pool timeout.  This new connection
+  pool is simpler than the default connection pool.  It is not yet
+  the default connection pool on Ruby 3.2, but it may become the
+  default in a later version.  Users of Ruby 3.2 are encouraged to
+  try out the pool_class: :timed_queue Database option and provide
+  feedback on how it works in their application.
+
+= Other Improvements
+
+* The tactical_eager_loading plugin now works in combination with the
+  single_table_inheritance and class_table_inheritance plugins, when
+  loading an association only defined in a specific subclass.
+  Previously, eager loading would be skipped in such a case.  Now,
+  an eager load will be attempted for all instances supporting the
+  association.
+
+* The validate_associated plugin now avoids database type errors for
+  non-integer association keys.  In cases where the associated object
+  doesn't have a value for the associated key, and the current object
+  does not have a key value that can be set in the associated object,
+  validation errors in the associated object related to the associated
+  key will be ignored.
+
+* Thread-keyed connection pool hashes now use compare_by_identity for
+  better performance.
+
+* The JRuby workaround in the named_timezones extension is no longer
+  used on JRuby 9.3.9.0+, as JRuby fixed the related bug.

data/doc/release_notes/5.64.0.txt

@@ -0,0 +1,50 @@
+= New Features
+
+* A :graph_use_association_block association option has been added,
+  which makes eager_graph use the association block (as eager does),
+  generally resulting in a JOIN to a subquery:
+
+    Artist.one_to_many :tracks, graph_use_association_block: true do |ds|
+      ds.where(foo: 3)
+    end
+    Artist.eager_graph(:tracks)
+    # SELECT albums.id, tracks.id AS tracks_id, tracks.album_id
+    # FROM albums
+    # LEFT OUTER JOIN (SELECT * FROM tracks WHERE (foo = 3)) AS tracks
+    # ON (tracks.album_id = albums.id)
+
+  Assuming that the database can optimize the query correctly, using
+  the :graph_use_association_block option is probably simpler than
+  than using other :graph_* options to duplicate the conditions added
+  by the association block.
+
+* Numeric/Decimal column schema entries now include :min_value and
+  :max_value entries on most databases, indicating the minimum and
+  maximum values supported for the column. Similar to the support
+  for integer columns added in 5.62.0, this allows the
+  auto_validations plugin to automatically validate the values of
+  the columns are in the allowed range.
+
+= Other Improvements
+
+* many_through_{one,many} associations now support eager_graph
+  callbacks.
+
+* The :db_type column schema entries on SQLAnywhere now include
+  precision/scale information, to work with the numeric/decimal
+  column min_value/max_value support.
+
+* The oracle adapter now includes a :column_size column schema
+  entry containing the precision of the columns, to work with the
+  numeric/decimal column min_value/max_value support.
+
+= Backwards Compatibility
+
+* The private Database#column_schema_integer_min_max_values method
+  added in 5.62.0 now takes a column schema hash instead of a
+  database type string.
+
+* Code that previously looked at the :db_type column schema entry on
+  SQLAnywhere should be updated to look at the :domain_name entry, and
+  code that looked at the :domain_name_with_size entry should be
+  updated to look at the :db_type entry.

data/lib/sequel/adapters/oracle.rb

@@ -312,6 +312,7 @@ module Sequel
               :char_used => column.char_used?,
               :char_size => column.char_size,
               :data_size => column.data_size,
+              :column_size => column.precision,
               :precision => column.precision,
               :scale => column.scale,
               :fsprecision => column.fsprecision,

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

@@ -60,8 +60,8 @@ module Sequel
       # Access's Byte type will accept much larger values,
       # even though it only stores 0-255.  Do not set min/max
       # values for the Byte type.
-      def column_schema_integer_min_max_values(db_type)
-        return if /byte/i =~ db_type
+      def column_schema_integer_min_max_values(column)
+        return if /byte/i =~ column[:db_type]
         super
       end
 

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

@@ -553,7 +553,7 @@ module Sequel
       # Return nil if CHECK constraints are not supported, because
       # versions that don't support check constraints don't raise
       # errors for values outside of range.
-      def column_schema_integer_min_max_values(db_type)
+      def column_schema_integer_min_max_values(column)
         super if supports_check_constraints?
       end
 

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

@@ -178,11 +178,11 @@ module Sequel
         ''
       end
 
-      # Do not support min/max integer values on Oracle, since
-      # Oracle uses a number type, and integer just adds a
-      # constaint on the number type.
-      def column_schema_integer_min_max_values(db_type)
-        nil
+      # Support min/max integer values on Oracle only if
+      # they use a NUMBER column with a fixed precision
+      # and no scale.
+      def column_schema_integer_min_max_values(column)
+        super if column[:db_type] =~ /NUMBER\(\d+\)/i || (column[:db_type] == 'NUMBER' && column[:column_size].is_a?(Integer) && column[:scale] == 0)
       end
 
       def create_sequence_sql(name, opts=OPTS)

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

@@ -37,7 +37,7 @@ module Sequel
           row[:auto_increment] = auto_increment == 1 || auto_increment == true
           row[:primary_key] = row.delete(:pkey) == 'Y'
           row[:allow_null] = row[:nulls_allowed].is_a?(Integer) ? row.delete(:nulls_allowed) == 1 : row.delete(:nulls_allowed)
-          row[:db_type] = row.delete(:domain_name)
+          row[:db_type] = row.delete(:domain_name_with_size)
           row[:type] = if row[:db_type] =~ /numeric/i and (row[:scale].is_a?(Integer) ? row[:scale] == 0 : !row[:scale])
             :integer
           else

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

@@ -320,10 +320,11 @@ module Sequel
         end
       end
     
-      # SQLite does not restrict the integer type to a specific range.
-      def column_schema_integer_min_max_values(db_type)
+      # SQLite does not restrict the integer or decimal type to a specific range.
+      def column_schema_integer_min_max_values(column)
         nil
       end
+      alias column_schema_decimal_min_max_values column_schema_integer_min_max_values
 
       # Array of PRAGMA SQL statements based on the Database options that should be applied to
       # new connections.

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -22,6 +22,8 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     @connections_to_disconnect = []
     @servers = opts.fetch(:servers_hash, Hash.new(:default))
     remove_instance_variable(:@waiter)
+    remove_instance_variable(:@allocated)
+    @allocated = {}
     @waiters = {}
 
     add_servers([:default])
@@ -36,7 +38,9 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
         unless @servers.has_key?(server)
           @servers[server] = server
           @available_connections[server] = []
-          @allocated[server] = {}
+          allocated = {}
+          allocated.compare_by_identity
+          @allocated[server] = allocated
           @waiters[server] = ConditionVariable.new
         end
       end

data/lib/sequel/connection_pool/threaded.rb

@@ -3,7 +3,7 @@
 # A connection pool allowing multi-threaded access to a pool of connections.
 # This is the default connection pool used by Sequel.
 class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
-  USE_WAITER = true
+  USE_WAITER = true # SEQUEL6: Remove
   Sequel::Deprecation.deprecate_constant(self, :USE_WAITER)
 
   # The maximum number of connections this pool will create (per shard/server
@@ -12,17 +12,17 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   
   # An array of connections that are available for use by the pool.
   # The calling code should already have the mutex before calling this.
-  attr_reader :available_connections
+  attr_reader :available_connections # SEQUEL6: Remove
   
-  # A hash with thread keys and connection values for currently allocated connections.
+  # A hash with thread/fiber keys and connection values for currently allocated connections.
   # The calling code should already have the mutex before calling this.
-  attr_reader :allocated
+  attr_reader :allocated # SEQUEL6: Remove
 
   # The following additional options are respected:
   # :max_connections :: The maximum number of connections the connection pool
   #                     will open (default 4)
   # :pool_timeout :: The amount of seconds to wait to acquire a connection
-  #                  before raising a PoolTimeoutError (default 5)
+  #                  before raising a PoolTimeout error (default 5)
   def initialize(db, opts = OPTS)
     super
     @max_size = Integer(opts[:max_connections] || 4)
@@ -31,6 +31,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     @connection_handling = opts[:connection_handling]
     @available_connections = []
     @allocated = {}
+    @allocated.compare_by_identity
     @timeout = Float(opts[:pool_timeout] || 5)
     @waiter = ConditionVariable.new
   end
@@ -49,8 +50,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     end
   end
   
-  # Removes all connections currently available, optionally
-  # yielding each connection to the given block. This method has the effect of 
+  # Removes all connections currently available. This method has the effect of 
   # disconnecting from the database, assuming that no connections are currently
   # being used.  If you want to be able to disconnect connections that are
   # currently in use, use the ShardedThreadedConnectionPool, which can do that.
@@ -134,7 +134,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # calling this.
   #
   # This should return a connection is one is available within the timeout,
-  # or nil if a connection could not be acquired within the timeout.
+  # or raise PoolTimeout if a connection could not be acquired within the timeout.
   def acquire(thread)
     if conn = assign_connection(thread)
       return conn

data/lib/sequel/connection_pool/timed_queue.rb

@@ -0,0 +1,257 @@
+# frozen-string-literal: true
+
+# :nocov:
+raise LoadError, "Sequel::TimedQueueConnectionPool is only available on Ruby 3.2+" unless RUBY_VERSION >= '3.2'
+# :nocov:
+
+# A connection pool allowing multi-threaded access to a pool of connections,
+# using a timed queue (only available in Ruby 3.2+).
+class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
+  # The maximum number of connections this pool will create.
+  attr_reader :max_size
+  
+  # The following additional options are respected:
+  # :max_connections :: The maximum number of connections the connection pool
+  #                     will open (default 4)
+  # :pool_timeout :: The amount of seconds to wait to acquire a connection
+  #                  before raising a PoolTimeout (default 5)
+  def initialize(db, opts = OPTS)
+    super
+    @max_size = Integer(opts[:max_connections] || 4)
+    raise(Sequel::Error, ':max_connections must be positive') if @max_size < 1
+    @mutex = Mutex.new  
+    # Size inside array so this still works while the pool is frozen.
+    @size = [0]
+    @allocated = {}
+    @allocated.compare_by_identity
+    @timeout = Float(opts[:pool_timeout] || 5)
+    @queue = Queue.new
+  end
+
+  # Yield all of the available connections, and the one currently allocated to
+  # this thread.  This will not yield connections currently allocated to other
+  # threads, as it is not safe to operate on them.
+  def all_connections
+    hold do |conn|
+      yield conn
+
+      # Use a hash to record all connections already seen.  As soon as we
+      # come across a connection we've already seen, we stop the loop.
+      conns = {}
+      conns.compare_by_identity
+      while true
+        conn = nil
+        begin
+          break unless (conn = @queue.pop(timeout: 0)) && !conns[conn]
+          conns[conn] = true
+          yield conn
+        ensure
+          @queue.push(conn) if conn
+        end
+      end
+    end
+  end
+  
+  # Removes all connections currently in the pool's queue. This method has the effect of 
+  # disconnecting from the database, assuming that no connections are currently
+  # being used.
+  # 
+  # Once a connection is requested using #hold, the connection pool
+  # creates new connections to the database.
+  def disconnect(opts=OPTS)
+    while conn = @queue.pop(timeout: 0)
+      disconnect_connection(conn)
+    end
+    fill_queue
+    nil
+  end
+
+  # Chooses the first available connection, or if none are
+  # available, creates a new connection.  Passes the connection to the supplied
+  # block:
+  # 
+  #   pool.hold {|conn| conn.execute('DROP TABLE posts')}
+  # 
+  # Pool#hold is re-entrant, meaning it can be called recursively in
+  # the same thread without blocking.
+  #
+  # If no connection is immediately available and the pool is already using the maximum
+  # number of connections, Pool#hold will block until a connection
+  # is available or the timeout expires.  If the timeout expires before a
+  # connection can be acquired, a Sequel::PoolTimeout is raised.
+  def hold(server=nil)
+    t = Sequel.current
+    if conn = sync{@allocated[t]}
+      return yield(conn)
+    end
+
+    begin
+      conn = acquire(t)
+      yield conn
+    rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+      if disconnect_error?(e)
+        oconn = conn
+        conn = nil
+        disconnect_connection(oconn) if oconn
+        sync{@allocated.delete(t)}
+        fill_queue
+      end
+      raise
+    ensure
+      release(t) if conn
+    end
+  end
+
+  def pool_type
+    :timed_queue
+  end
+  
+  # The total number of connections in the pool.
+  def size
+    sync{@size[0]}
+  end
+  
+  private
+
+  # Create a new connection, after the pool's current size has already
+  # been updated to account for the new connection.  If there is an exception
+  # when creating the connection, decrement the current size.
+  #
+  # This should only be called after can_make_new?.  If there is an exception
+  # between when can_make_new? is called and when preallocated_make_new
+  # is called, it has the effect of reducing the maximum size of the
+  # connection pool by 1, since the current size of the pool will show a
+  # higher number than the number of connections allocated or
+  # in the queue.
+  #
+  # Calling code should not have the mutex when calling this.
+  def preallocated_make_new
+    make_new(:default)
+  rescue Exception
+    sync{@size[0] -= 1}
+    raise
+  end
+
+  # Decrement the current size of the pool when disconnecting connections.
+  #
+  # Calling code should not have the mutex when calling this.
+  def disconnect_connection(conn)
+    sync{@size[0] -= 1}
+    super
+  end
+
+  # If there are any threads waiting on the queue, try to create
+  # new connections in a separate thread if the pool is not yet at the
+  # maximum size.
+  #
+  # The reason for this method is to handle cases where acquire
+  # could not retrieve a connection immediately, and the pool
+  # was already at the maximum size.  In that case, the acquire will
+  # wait on the queue until the timeout.  This method is called
+  # after disconnecting to potentially add new connections to the
+  # pool, so the threads that are currently waiting for connections
+  # do not timeout after the pool is no longer full.
+  def fill_queue
+    if @queue.num_waiting > 0
+      Thread.new do
+        while @queue.num_waiting > 0 && (conn = try_make_new)
+          @queue.push(conn)
+        end
+      end
+    end
+  end
+
+  # Whether the given size is less than the maximum size of the pool.
+  # In that case, the pool's current size is incremented.  If this
+  # method returns true, space in the pool for the connection is
+  # preallocated, and preallocated_make_new should be called to
+  # create the connection.
+  #
+  # Calling code should have the mutex when calling this.
+  def can_make_new?(current_size)
+    if @max_size > current_size
+      @size[0] += 1
+    end
+  end
+
+  # Try to make a new connection if there is space in the pool.
+  # If the pool is already full, look for dead threads/fibers and
+  # disconnect the related connections.
+  #
+  # Calling code should not have the mutex when calling this.
+  def try_make_new
+    return preallocated_make_new if sync{can_make_new?(@size[0])}
+
+    to_disconnect = nil
+    do_make_new = false
+
+    sync do
+      current_size = @size[0]
+      @allocated.keys.each do |t|
+        unless t.alive?
+          (to_disconnect ||= []) << @allocated.delete(t)
+          current_size -= 1
+        end
+      end
+    
+      do_make_new = true if can_make_new?(current_size)
+    end
+
+    begin
+      preallocated_make_new if do_make_new
+    ensure
+      if to_disconnect
+        to_disconnect.each{|conn| disconnect_connection(conn)}
+        fill_queue
+      end
+    end
+  end
+  
+  # Assigns a connection to the supplied thread, if one
+  # is available.
+  #
+  # This should return a connection is one is available within the timeout,
+  # or raise PoolTimeout if a connection could not be acquired within the timeout.
+  #
+  # Calling code should not have the mutex when calling this.
+  def acquire(thread)
+    if conn = @queue.pop(timeout: 0) || try_make_new || @queue.pop(timeout: @timeout)
+      sync{@allocated[thread] = conn}
+    else
+      name = db.opts[:name]
+      raise ::Sequel::PoolTimeout, "timeout: #{@timeout}#{", database name: #{name}" if name}"
+    end
+  end
+
+  # Create the maximum number of connections immediately. This should not be called
+  # with a true argument unles no code is currently operating on the database.
+  #
+  # Calling code should not have the mutex when calling this.
+  def preconnect(concurrent = false)
+    if concurrent
+      if times = sync{@max_size > (size = @size[0]) ? @max_size - size : false}
+        times.times.map{Thread.new{if conn = try_make_new; @queue.push(conn) end}}.map(&:value)
+      end
+    else
+      while conn = try_make_new
+        @queue.push(conn)
+      end
+    end
+
+    nil
+  end
+
+  # Releases the connection assigned to the supplied thread back to the pool.
+  #
+  # Calling code should not have the mutex when calling this.
+  def release(thread)
+    @queue.push(sync{@allocated.delete(thread)})
+  end
+
+  # Yield to the block while inside the mutex.
+  #
+  # Calling code should not have the mutex when calling this.
+  def sync
+    @mutex.synchronize{yield}
+  end
+end

data/lib/sequel/connection_pool.rb

@@ -30,8 +30,11 @@ class Sequel::ConnectionPool
     :threaded => :ThreadedConnectionPool,
     :single => :SingleConnectionPool,
     :sharded_threaded => :ShardedThreadedConnectionPool,
-    :sharded_single => :ShardedSingleConnectionPool
-  }.freeze
+    :sharded_single => :ShardedSingleConnectionPool,
+    :timed_queue => :TimedQueueConnectionPool,
+  }
+  POOL_CLASS_MAP.to_a.each{|k, v| POOL_CLASS_MAP[k.to_s] = v}
+  POOL_CLASS_MAP.freeze
 
   # Class methods used to return an appropriate pool subclass, separated
   # into a module for easier overridding by extensions.

data/lib/sequel/database/query.rb

@@ -175,8 +175,14 @@ module Sequel
         if !c[:max_length] && c[:type] == :string && (max_length = column_schema_max_length(c[:db_type]))
           c[:max_length] = max_length
         end
-        if !c[:max_value] && !c[:min_value] && c[:type] == :integer && (min_max = column_schema_integer_min_max_values(c[:db_type]))
-          c[:min_value], c[:max_value] = min_max
+        if !c[:max_value] && !c[:min_value]
+          min_max = case c[:type]
+          when :integer
+            column_schema_integer_min_max_values(c)
+          when :decimal
+            column_schema_decimal_min_max_values(c)
+          end
+          c[:min_value], c[:max_value] = min_max if min_max
         end
       end
       schema_post_process(cols)
@@ -288,7 +294,15 @@ module Sequel
 
     # Look at the db_type and guess the minimum and maximum integer values for
     # the column.
-    def column_schema_integer_min_max_values(db_type)
+    def column_schema_integer_min_max_values(column)
+      db_type = column[:db_type]
+      if /decimal|numeric|number/i =~ db_type
+        if min_max = column_schema_decimal_min_max_values(column)
+          min_max.map!(&:to_i)
+        end
+        return min_max
+      end
+
       unsigned = /unsigned/i =~ db_type
       case db_type
       when /big|int8/i
@@ -304,6 +318,26 @@ module Sequel
       end
     end
 
+    # Look at the db_type and guess the minimum and maximum decimal values for
+    # the column.
+    def column_schema_decimal_min_max_values(column)
+      if column[:column_size] && column[:scale]
+        precision = column[:column_size]
+        scale = column[:scale]
+      elsif /\((\d+)(?:,\s*(-?\d+))?\)/ =~ column[:db_type]
+        precision = $1.to_i
+        scale = $2.to_i if $2
+      end
+
+      if precision
+        limit = BigDecimal("9" * precision)
+        if scale
+          limit /= 10**(scale)
+        end
+        [-limit, limit]
+      end
+    end
+
     # Whether the tinyint type (if supported by the database) is unsigned by default.
     def column_schema_tinyint_type_is_unsigned?
       false
@@ -370,7 +404,7 @@ module Sequel
         :boolean
       when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
         :float
-      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+|false|true)\))?))\z/io
+      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(-?\d+|false|true)\))?))\z/io
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal
       when /bytea|blob|image|(var)?binary/io
         :blob

data/lib/sequel/dataset/actions.rb

@@ -127,6 +127,18 @@ module Sequel
     #
     #   DB[:table].delete # DELETE * FROM table
     #   # => 3
+    #
+    # Some databases support using multiple tables in a DELETE query. This requires
+    # multiple FROM tables (JOINs can also be used). As multiple FROM tables use
+    # an implicit CROSS JOIN, you should make sure your WHERE condition uses the
+    # appropriate filters for the FROM tables:
+    #
+    #  DB.from(:a, :b).join(:c, :d=>Sequel[:b][:e]).where{{a[:f]=>b[:g], a[:id]=>c[:h]}}.
+    #    delete
+    #  # DELETE FROM a
+    #  # USING b
+    #  # INNER JOIN c ON (c.d = b.e)
+    #  # WHERE ((a.f = b.g) AND (a.id = c.h))
     def delete(&block)
       sql = delete_sql
       if uses_returning?(:delete)
@@ -926,6 +938,19 @@ module Sequel
     #
     #   DB[:table].update(x: Sequel[:x]+1, y: 0) # UPDATE table SET x = (x + 1), y = 0
     #   # => 10
+    #
+    # Some databases support using multiple tables in an UPDATE query. This requires
+    # multiple FROM tables (JOINs can also be used). As multiple FROM tables use
+    # an implicit CROSS JOIN, you should make sure your WHERE condition uses the
+    # appropriate filters for the FROM tables:
+    #
+    #  DB.from(:a, :b).join(:c, :d=>Sequel[:b][:e]).where{{a[:f]=>b[:g], a[:id]=>10}}.
+    #    update(:f=>Sequel[:c][:h])
+    #  # UPDATE a
+    #  # SET f = c.h
+    #  # FROM b
+    #  # INNER JOIN c ON (c.d = b.e)
+    #  # WHERE ((a.f = b.g) AND (a.id = 10))
     def update(values=OPTS, &block)
       sql = update_sql(values)
       if uses_returning?(:update)

data/lib/sequel/extensions/async_thread_pool.rb

@@ -5,7 +5,7 @@
 # code
 #
 #   DB.extension :async_thread_pool
-#   foos = DB[:foos].async.where{name: 'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bar].async.select_order_map(:name)
 #   baz_1 = DB[:bazes].async.first(id: 1)
 #
@@ -15,7 +15,7 @@
 # of calling that method on the result of the query method. For example,
 # if you run:
 #
-#   foos = DB[:foos].async.where{name: 'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bars].async.select_order_map(:name)
 #   baz_1 = DB[:bazes].async.first(id: 1)
 #   sleep(1)
@@ -26,7 +26,7 @@
 # These three queries will generally be run concurrently in separate
 # threads.  If you instead run:
 #   
-#   DB[:foos].async.where{name: 'A'..'M'}.all.size
+#   DB[:foos].async.where(name: 'A'..'M').all.size
 #   DB[:bars].async.select_order_map(:name).first
 #   DB[:bazes].async.first(id: 1).name
 #
@@ -37,7 +37,7 @@
 # What is run in the separate thread is the entire method call that
 # returns results.  So with the original example:
 #
-#   foos = DB[:foos].async.where{name: 'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bars].async.select_order_map(:name)
 #   baz_1 = DB[:bazes].async.first(id: 1)
 #
@@ -156,7 +156,7 @@
 # so that the query will run in the current thread instead of waiting
 # for an async thread to become available.  With the following code:
 #
-#   foos = DB[:foos].async.where{name: 'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bar].async.select_order_map(:name)
 #   if foos.length > 4
 #     baz_1 = DB[:bazes].async.first(id: 1)

data/lib/sequel/extensions/named_timezones.rb

@@ -68,6 +68,10 @@ module Sequel
     private 
     
     if RUBY_VERSION >= '2.6'
+      # Whether Time.at with :nsec and :in is broken.  True on JRuby < 9.3.9.0.
+      BROKEN_TIME_AT_WITH_NSEC = defined?(JRUBY_VERSION) && (JRUBY_VERSION < '9.3' || (JRUBY_VERSION < '9.4' && JRUBY_VERSION.split('.')[2].to_i < 9))
+      private_constant :BROKEN_TIME_AT_WITH_NSEC
+
       # Convert the given input Time (which must be in UTC) to the given input timezone,
       # which should be a TZInfo::Timezone instance.
       def convert_input_time_other(v, input_timezone)
@@ -77,7 +81,7 @@ module Sequel
         period = input_timezone.period_for_local(v, &disamb)
         offset = period.utc_total_offset
         # :nocov:
-        if defined?(JRUBY_VERSION)
+        if BROKEN_TIME_AT_WITH_NSEC
           Time.at(v.to_i - offset, :in => input_timezone) + v.nsec/1000000000.0
         # :nocov:
         else
@@ -89,7 +93,7 @@ module Sequel
       # which should be a TZInfo::Timezone instance.
       def convert_output_time_other(v, output_timezone)
         # :nocov:
-        if defined?(JRUBY_VERSION)
+        if BROKEN_TIME_AT_WITH_NSEC
           Time.at(v.to_i, :in => output_timezone) + v.nsec/1000000000.0
         # :nocov:
         else

data/lib/sequel/model/associations.rb

@@ -1722,6 +1722,8 @@ module Sequel
         # :graph_select :: A column or array of columns to select from the associated table
         #                  when eagerly loading the association via +eager_graph+. Defaults to all
         #                  columns in the associated table.
+        # :graph_use_association_block :: Makes eager_graph consider the association block. Without this, eager_graph
+        #                                 ignores the bock and only use the :graph_* options.
         # :instance_specific :: Marks the association as instance specific. Should be used if the association block
         #                       uses instance specific state, or transient state (accessing current date/time, etc.).
         # :limit :: Limit the number of records to the provided value.  Use
@@ -2461,6 +2463,9 @@ module Sequel
         # Return dataset to graph into given the association reflection, applying the :callback option if set.
         def eager_graph_dataset(opts, eager_options)
           ds = opts.associated_class.dataset
+          if opts[:graph_use_association_block] && (b = opts[:block])
+            ds = b.call(ds)
+          end
           if cb = eager_options[:callback]
             ds = cb.call(ds)
           end
@@ -3552,11 +3557,11 @@ module Sequel
         end
 
         # Eagerly load all specified associations.
-        def eager_load(a, eager_assoc=@opts[:eager])
+        def eager_load(a, eager_assoc=@opts[:eager], m=model)
           return if a.empty?
 
           # Reflections for all associations to eager load
-          reflections = eager_assoc.keys.map{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
+          reflections = eager_assoc.keys.map{|assoc| m.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
 
           perform_eager_loads(prepare_eager_load(a, reflections, eager_assoc))
 

data/lib/sequel/plugins/many_through_many.rb

@@ -385,7 +385,7 @@ module Sequel
                 iq = nil
               end
               fe = opts.final_edge
-              ds.graph(opts.associated_class.dataset, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
+              ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
             end
           end
         end

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -253,6 +253,14 @@ module Sequel
 
         private
 
+        # Limit tactical eager loading objects to objects that support the same association.
+        def _filter_tactical_eager_load_objects(opts)
+          objects = defined?(super) ? super : retrieved_with.dup
+          name = opts[:name]
+          objects.select!{|x| x.model.association_reflections.include?(name)}
+          objects
+        end
+
         # Don't allow use of prepared statements.
         def use_prepared_statements_for?(type)
           false

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -152,23 +152,23 @@ module Sequel
           name = opts[:name]
           eager_reload = dynamic_opts[:eager_reload]
           if (!associations.include?(name) || eager_reload) && opts[:allow_eager] != false && retrieved_by && !frozen? && !dynamic_opts[:callback] && !dynamic_opts[:reload]
-            begin
-              objects = if eager_reload
-                retrieved_with.reject(&:frozen?)
-              else
-                retrieved_with.reject{|x| x.frozen? || x.associations.include?(name)}
-              end
-              retrieved_by.send(:eager_load, objects, name=>dynamic_opts[:eager] || OPTS)
-            rescue Sequel::UndefinedAssociation
-              # This can happen if class table inheritance is used and the association
-              # is only defined in a subclass.  This particular instance can use the
-              # association, but it can't be eagerly loaded as the parent class doesn't
-              # have access to the association, and that's the class doing the eager loading.
-              nil
-            end
+            retrieved_by.send(:eager_load, _filter_tactical_eager_load_objects(:eager_reload=>eager_reload, :name=>name), {name=>dynamic_opts[:eager] || OPTS}, model)
           end
           super
         end
+
+        # Filter the objects used when tactical eager loading.
+        # By default, this removes frozen objects and objects that alreayd have the association loaded
+        def _filter_tactical_eager_load_objects(opts)
+          objects = defined?(super) ? super : retrieved_with.dup
+          if opts[:eager_reload]
+            objects.reject!(&:frozen?)
+          else
+            name = opts[:name]
+            objects.reject!{|x| x.frozen? || x.associations.include?(name)}
+          end
+          objects
+        end
       end
 
       module DatasetMethods

data/lib/sequel/plugins/validate_associated.rb

@@ -2,7 +2,7 @@
 
 module Sequel
   module Plugins
-    # The validates_associated plugin allows you to validate associated
+    # The validate_associated plugin allows you to validate associated
     # objects.  It also offers the ability to delay the validation of
     # associated objects until the current object is validated.
     # If the associated object is invalid, validation error messages
@@ -54,22 +54,32 @@ module Sequel
           return if reflection[:validate] == false
           association = reflection[:name]
           if (reflection[:type] == :one_to_many || reflection[:type] == :one_to_one) && (key = reflection[:key]).is_a?(Symbol) && !(pk_val = obj.values[key])
-            # There could be a presence validation on the foreign key in the associated model,
-            # which will fail if we validate before saving the current object.  If there is
-            # no value for the foreign key, set it to the current primary key value, or a dummy
-            # value of 0 if we haven't saved the current object.
             p_key = pk unless pk.is_a?(Array)
-            obj.values[key] = p_key || 0
-            key = nil if p_key
+            if p_key
+              obj.values[key] = p_key
+            else
+              ignore_key_errors = true
+            end
           end
-          obj.errors.full_messages.each{|m| errors.add(association, m)} unless obj.valid?
-          if key && !pk_val
-            # If we used a dummy value of 0, remove it so it doesn't accidently remain.
-            obj.values.delete(key)
+
+          unless obj.valid?
+            if ignore_key_errors
+              # Ignore errors on the key column in the associated object. This column
+              # will be set when saving to a presumably valid value using a column
+              # in the current object (which may not be available until after the current
+              # object is saved).
+              obj.errors.delete(key)
+              obj.errors.delete_if{|k,| Array === k && k.include?(key)}
+            end
+
+            obj.errors.full_messages.each do |m|
+              errors.add(association, m)
+            end
           end
+
+          nil
         end
       end
     end
   end
 end
-

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 = 62
+  MINOR = 64
 
   # 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.62.0
+  version: 5.64.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-01 00:00:00.000000000 Z
+date: 2023-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -194,6 +194,8 @@ extra_rdoc_files:
 - doc/release_notes/5.60.0.txt
 - doc/release_notes/5.61.0.txt
 - doc/release_notes/5.62.0.txt
+- doc/release_notes/5.63.0.txt
+- doc/release_notes/5.64.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
@@ -284,6 +286,8 @@ files:
 - doc/release_notes/5.60.0.txt
 - doc/release_notes/5.61.0.txt
 - doc/release_notes/5.62.0.txt
+- doc/release_notes/5.63.0.txt
+- doc/release_notes/5.64.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
@@ -352,6 +356,7 @@ files:
 - lib/sequel/connection_pool/sharded_threaded.rb
 - lib/sequel/connection_pool/single.rb
 - lib/sequel/connection_pool/threaded.rb
+- lib/sequel/connection_pool/timed_queue.rb
 - lib/sequel/core.rb
 - lib/sequel/database.rb
 - lib/sequel/database/connecting.rb
@@ -606,7 +611,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: The Database Toolkit for Ruby