pgtk 0.32.5 → 0.32.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1997e1fa9261d1881e5df4495a43723ea737ad754806bc9908a986c4e782fa6
-  data.tar.gz: 51b31ffb42b6eb9d2ea625c82be4664384bc190d2c1187ab642cb7cbeaaeb9ab
+  metadata.gz: 54a200f1f191d63b73c0137b1a1ace4aa34667f041d141365b47d9c90d96f191
+  data.tar.gz: 1518e5031b71a69e3955cabe77397d05917398fb87a12b94ee5c3aa57ab107eb
 SHA512:
-  metadata.gz: f6245814e1907f27948dd369e8ff00cf584e759c04c7b22befac1c4da3de828ef6192f8d3510fe6760b04cdbab871045a7963ed54c00cd1d64b982b2ccfb483d
-  data.tar.gz: 5f97bf03bf00fc4e4da554b1807896474d4221748ebacc3cbda22da56e6d55e3067dd5e277082c7a4184aabe4617df9ece91e6dfaaec718f2530f7acc4410664
+  metadata.gz: 28bbce0d3b2cfcbe2347f376738938e0e714f22b89fd2696052c56ecf7be83c242e9f0a87c76c235f109ec2008a45a1471ea157fc78f3ac9a8b8b71641ac2556
+  data.tar.gz: e94795ee7e4de524c77b5fddefb7a0d2ea9e85ec05beb09ebf81000919afec9a7b54d8a0fb480d9e24c16990fed7b7b142769caefddaefdd32d504f8086f5f46

data/Gemfile.lock

@@ -2,7 +2,7 @@ PATH
   remote: .
   specs:
     pgtk (0.0.0)
-      backtrace (~> 0.4)
+      cgi (~> 0.0)
       concurrent-ruby (~> 1.3)
       donce (~> 0.0)
       ellipsized (~> 0.3)
@@ -22,7 +22,8 @@ GEM
     ast (2.4.3)
     backtrace (0.4.1)
     builder (3.3.0)
-    concurrent-ruby (1.3.6)
+    cgi (0.5.1)
+    concurrent-ruby (1.3.7)
     differ (0.1.2)
     docile (1.4.1)
     donce (0.7.0)
@@ -35,7 +36,7 @@ GEM
       tago (~> 0.1)
     ellipsized (0.3.0)
     joined (0.4.0)
-    json (2.19.5)
+    json (2.19.9)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     logger (1.7.0)
@@ -52,21 +53,21 @@ GEM
       minitest (>= 5.0, < 7)
       ruby-progressbar
     minitest-stub-const (0.6)
-    nokogiri (1.19.3-aarch64-linux-gnu)
+    nokogiri (1.19.4-aarch64-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.19.3-aarch64-linux-musl)
+    nokogiri (1.19.4-aarch64-linux-musl)
       racc (~> 1.4)
-    nokogiri (1.19.3-arm-linux-gnu)
+    nokogiri (1.19.4-arm-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.19.3-arm-linux-musl)
+    nokogiri (1.19.4-arm-linux-musl)
       racc (~> 1.4)
-    nokogiri (1.19.3-arm64-darwin)
+    nokogiri (1.19.4-arm64-darwin)
       racc (~> 1.4)
-    nokogiri (1.19.3-x86_64-darwin)
+    nokogiri (1.19.4-x86_64-darwin)
       racc (~> 1.4)
-    nokogiri (1.19.3-x86_64-linux-gnu)
+    nokogiri (1.19.4-x86_64-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.19.3-x86_64-linux-musl)
+    nokogiri (1.19.4-x86_64-linux-musl)
       racc (~> 1.4)
     os (1.1.4)
     parallel (2.1.0)
@@ -94,7 +95,7 @@ GEM
       tago (~> 0.0)
     regexp_parser (2.12.0)
     rexml (3.4.4)
-    rubocop (1.86.2)
+    rubocop (1.87.0)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
@@ -108,7 +109,7 @@ GEM
     rubocop-ast (1.49.1)
       parser (>= 3.3.7.2)
       prism (~> 1.7)
-    rubocop-elegant (0.5.0)
+    rubocop-elegant (0.6.0)
       lint_roller (~> 1.1)
       rubocop (~> 1.75)
     rubocop-minitest (0.39.1)
@@ -147,7 +148,7 @@ GEM
       nokogiri (~> 1.8)
       rainbow (~> 3.0)
       slop (~> 4.4)
-    yard (0.9.43)
+    yard (0.9.44)
 
 PLATFORMS
   aarch64-linux

data/README.md

@@ -243,6 +243,18 @@ You can exclude specific queries from timeout enforcement using regex patterns:
 impatient = Pgtk::Impatient.new(pool, 2, /^SELECT/, /^VACUUM/)
 ```
 
+Excluded queries are never wrapped in a transaction, because statements such as
+`VACUUM`, `REINDEX`, or `CREATE INDEX CONCURRENTLY` cannot run inside a
+transaction block. Instead, a longer fallback timeout (300 seconds by default,
+configurable via the `default:` argument) is applied at the session level with
+`SET statement_timeout` before the query runs, and reset afterwards. Pass
+`default: 0` to run excluded queries with no timeout at all:
+
+```ruby
+# Give excluded queries a 60-second fallback timeout
+impatient = Pgtk::Impatient.new(pool, 2, /^VACUUM/, default: 60)
+```
+
 The timeout is enforced on the server side: each query is wrapped in a tiny
 transaction that issues `SET LOCAL statement_timeout`, and PostgreSQL itself
 terminates the query at the deadline. This guarantees the server-side

data/lib/pgtk/impatient.rb

@@ -20,6 +20,14 @@ require_relative '../pgtk'
 # transaction-pool PgBouncer that does not forward client disconnects to in-flight
 # server queries). On timeout, +TooSlow+ is raised.
 #
+# Queries that match one of the +off+ regular expressions are excluded from
+# this checking. They are never wrapped in a transaction, because some
+# statements (such as +VACUUM+, +REINDEX+, or +CREATE INDEX CONCURRENTLY+)
+# cannot run inside a transaction block. Instead, a session-level
+# +SET statement_timeout+ is applied on the same connection before the query
+# runs (and reset afterwards), using the +default+ fallback timeout. Pass
+# +default: 0+ to run excluded queries with no timeout at all.
+#
 # Basic usage:
 #
 #   # Create and configure a regular pool
@@ -63,10 +71,12 @@ class Pgtk::Impatient
   # @param [Pgtk::Pool] pool The pool to decorate
   # @param [Integer] timeout Timeout in seconds for each SQL query
   # @param [Array<Regex>] off List of regex to exclude queries from checking
-  def initialize(pool, timeout, *off)
+  # @param [Integer] default Fallback timeout in seconds for excluded queries (0 = no timeout)
+  def initialize(pool, timeout, *off, default: 300)
     @pool = pool
     @timeout = timeout
     @off = off
+    @default = default
   end
 
   # Start a new connection pool with the given arguments.
@@ -86,7 +96,7 @@ class Pgtk::Impatient
     [
       @pool.dump,
       '',
-      "Pgtk::Impatient (timeout=#{@timeout}s):",
+      "Pgtk::Impatient (timeout=#{@timeout}s, default=#{@default}s):",
       @off.map { |re| "  #{re}" }
     ].join("\n")
   end
@@ -100,13 +110,27 @@ class Pgtk::Impatient
   # behind a transaction-pool PgBouncer). When the deadline fires, the
   # underlying +PG::QueryCanceled+ is translated to +TooSlow+.
   #
+  # Queries matching one of the +off+ regular expressions bypass this
+  # transaction. They run on a single connection without a transaction block,
+  # guarded by a session-level +SET statement_timeout+ (the +default+ fallback,
+  # reset afterwards) or by no timeout at all when +default+ is zero. This keeps
+  # statements that cannot run inside a transaction, such as +VACUUM+ or
+  # +REINDEX+, working as expected.
+  #
   # @param [String, Array] query The SQL query with params inside (possibly)
   # @param [Array] args List of arguments
   # @return [Array] Result rows
   # @raise [TooSlow] If the query takes too long
   def exec(query, *args)
     sql = query.is_a?(Array) ? query.join(' ') : query
-    return @pool.exec(sql, *args) if @off.any? { |re| re.match?(sql) }
+    if @off.any? { |re| re.match?(sql) }
+      ms = Integer(@default * 1000)
+      return @pool.exec(sql, *args) if ms.zero?
+      return @pool.session do |t|
+        t.exec("SET statement_timeout = #{ms}")
+        t.exec(sql, *args).tap { t.exec('RESET statement_timeout') }
+      end
+    end
     start = Time.now
     ms = [Integer(@timeout * 1000), 1].max
     begin

data/lib/pgtk/pgsql_task.rb

@@ -129,6 +129,10 @@ class Pgtk::PgsqlTask < Rake::TaskLib
       "-e POSTGRES_DB=#{Shellwords.escape(@dbname)}",
       '--detach',
       '--rm',
+      '--health-cmd', 'pg_isready',
+      '--health-interval', '1s',
+      '--health-timeout', '2s',
+      '--health-retries', '10',
       'postgres:18.1',
       @config.map { |k, v| "-c #{Shellwords.escape("#{k}=#{v}")}" },
       stdout:
@@ -148,6 +152,15 @@ class Pgtk::PgsqlTask < Rake::TaskLib
     rescue WaitUtil::TimeoutError => e
       raise(IOError, "Failed to start PostgreSQL Docker container #{container.inspect}: #{e.message}")
     end
+    (30 * 2).times do
+      status = qbash(
+        "docker inspect --format='{{.State.Health.Status}}' #{Shellwords.escape(container)}",
+        accept: nil, both: true
+      )[0]&.strip
+      break if status == 'healthy'
+      raise(IOError, "PostgreSQL container #{container.inspect} is #{status}") if status == 'unhealthy'
+      sleep(0.5)
+    end
     container
   end
 
@@ -181,13 +194,17 @@ class Pgtk::PgsqlTask < Rake::TaskLib
       puts("PostgreSQL killed in PID #{pid}") unless @quiet
     end
     begin
-      WaitUtil.wait_for_service('PG in local', 'localhost', port, timeout_sec: 10, delay_sec: 0.1)
+      WaitUtil.wait_for_service('PG in local', 'localhost', port, timeout_sec: 10, delay_sec: 0.2)
     rescue WaitUtil::TimeoutError => e
       puts("+ #{cmd}")
       puts("stdout:\n#{File.read(File.join(home, 'stdout.txt'))}")
       puts("stderr:\n#{File.read(File.join(home, 'stderr.txt'))}")
       raise(IOError, "Failed to start PostgreSQL database server on port #{port}: #{e.message}")
     end
+    (10 * 2).times do
+      break if qbash("pg_isready -h localhost -p #{port}", accept: nil, both: true)[1].zero?
+      sleep(0.5)
+    end
     qbash(
       'createdb',
       '--host', 'localhost',

data/lib/pgtk/pool.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'loog'
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
 require 'ellipsized'
+require 'loog'
 require 'pg'
 require 'tago'
 require_relative '../pgtk'
@@ -73,6 +73,7 @@ class Pgtk::Pool
     @idle = idle
     @log = log
     @pool = IterableQueue.new(max, timeout)
+    @lock = Mutex.new
     @started = false
   end
 
@@ -80,7 +81,12 @@ class Pgtk::Pool
   #
   # @return [String] Version of PostgreSQL server
   def version
-    @version ||= exec('SHOW server_version')[0]['server_version'].split[0]
+    @version ||=
+      begin
+        conn = @pool.pop
+        @pool.push(conn)
+        conn.parameter_status('server_version').split[0]
+      end
   end
 
   # Get as much details about it as possible.
@@ -103,20 +109,22 @@ class Pgtk::Pool
   # open at the same time. For example, Heroku free PostgreSQL database
   # allows only one connection open.
   def start!
-    return if @started
-    @max.times do
-      @pool.push(@wire.connection)
-    end
-    (2 * @max).times do
-      connect { |c| c.exec('SELECT 1') }
-    rescue StandardError => e
-      @log.warn("Pool warm-up query failed, slot will be retried: #{e.message.strip}")
-    end
-    @max.times do
-      connect { |c| c.exec('SELECT 1') }
+    @lock.synchronize do
+      return if @started
+      @max.times do
+        @pool.push(@wire.connection)
+      end
+      (2 * @max).times do
+        connect { |c| c.exec('SELECT 1') }
+      rescue StandardError => e
+        @log.warn("Pool warm-up query failed, slot will be retried: #{e.message.strip}")
+      end
+      @max.times do
+        connect { |c| c.exec('SELECT 1') }
+      end
+      @started = true
+      @log.debug("PostgreSQL pool started with #{@max} connections")
     end
-    @started = true
-    @log.debug("PostgreSQL pool started with #{@max} connections")
   end
 
   # Make a query and return the result as an array of hashes. For example,
@@ -206,6 +214,29 @@ class Pgtk::Pool
     end
   end
 
+  # Grab a single connection from the pool and yield an executor bound to it,
+  # WITHOUT starting a transaction. Unlike +transaction+, no +START TRANSACTION+
+  # is issued, which makes this suitable for statements that PostgreSQL refuses
+  # to run inside a transaction block, such as +VACUUM+, +REINDEX+, or
+  # +CREATE INDEX CONCURRENTLY+. All statements executed through the yielded
+  # object run on the same connection, so a session-level setting (for example
+  # +SET statement_timeout+) made earlier in the block stays in effect for the
+  # statements that follow:
+  #
+  #  pgsql.session do |s|
+  #    s.exec('SET statement_timeout = 5000')
+  #    s.exec('VACUUM book')
+  #    s.exec('RESET statement_timeout')
+  #  end
+  #
+  # @yield [Object] Yields an executor that responds to +exec+
+  # @return [Object] Result of the block
+  def session
+    connect do |c|
+      yield(Txn.new(c, @log))
+    end
+  end
+
   private
 
   def connect

data/lib/pgtk/spy.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'loog'
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
+require 'loog'
 require 'pg'
 require_relative '../pgtk'
 require_relative 'wire'
@@ -82,8 +82,10 @@ class Pgtk::Spy
   # @param [String] sql The SQL query with params inside (possibly)
   # @return [Array] Result rows
   def exec(sql, *)
-    @block&.call(sql.is_a?(Array) ? sql.join(' ') : sql, Time.now - Time.now)
-    @pool.exec(sql, *)
+    start = Time.now
+    @pool.exec(sql, *).tap do
+      @block&.call(sql.is_a?(Array) ? sql.join(' ') : sql, Time.now - start)
+    end
   end
 
   # Run a transaction with spying on each SQL query.
@@ -95,4 +97,15 @@ class Pgtk::Spy
       yield(Pgtk::Spy.new(t, &@block))
     end
   end
+
+  # Run statements on a single connection (no transaction) with spying on
+  # each SQL query.
+  #
+  # @yield [Pgtk::Spy] Yields a spy bound to one connection
+  # @return [Object] Result of the block
+  def session
+    @pool.session do |t|
+      yield(Pgtk::Spy.new(t, &@block))
+    end
+  end
 end

data/lib/pgtk/stash.rb

@@ -29,8 +29,11 @@ require_relative '../pgtk'
 # Copyright:: Copyright (c) 2019-2026 Yegor Bugayenko
 # License:: MIT
 class Pgtk::Stash
-  MODS = %w[INSERT DELETE UPDATE LOCK VACUUM TRANSACTION COMMIT ROLLBACK REINDEX TRUNCATE CREATE ALTER DROP SET].freeze
-  MODS_RE = Regexp.new("(^|\\s)(#{MODS.join('|')})(\\s|$)")
+  MODS = %w[
+    INSERT DELETE UPDATE LOCK VACUUM TRANSACTION COMMIT ROLLBACK
+    REINDEX TRUNCATE CREATE ALTER DROP SET START
+  ].freeze
+  MODS_RE = Regexp.new("\\A(#{MODS.join('|')})(\\s|$)")
 
   IDENT = '[a-z_][a-z0-9_]*'
 
@@ -39,9 +42,13 @@ class Pgtk::Stash
 
   READS_RE = Regexp.new("(?<=^|\\s)(?:FROM|JOIN)\\s(#{IDENT})(?=\\s|;|$)")
 
-  SEPARATOR = ' --%*@#~($-- '
+  NONDETERMINISTIC = /
+    \b(?:NOW|CURRENT_TIMESTAMP|CURRENT_DATE|CURRENT_TIME|
+    LOCALTIMESTAMP|LOCALTIME|RANDOM|GEN_RANDOM_UUID|
+    CLOCK_TIMESTAMP)(?:\s*\(|(?=[^a-z0-9_]|$))
+  /ix
 
-  private_constant :MODS, :ALTS, :IDENT, :MODS_RE, :ALTS_RE, :READS_RE, :SEPARATOR
+  private_constant :MODS, :ALTS, :IDENT, :MODS_RE, :ALTS_RE, :READS_RE, :NONDETERMINISTIC
 
   # Initialize a new Stash with query caching.
   #
@@ -76,7 +83,9 @@ class Pgtk::Stash
     @pool = pool
     @stash = stash
     @stash[:table_mod] ||= {}
-    @stash[:table_inflight] ||= {}
+    unless @stash[:table_inflight].default_proc
+      @stash[:table_inflight] = Hash.new { |h, k| h[k] = Concurrent::AtomicFixnum.new(0) }
+    end
     @loog = loog
     @entrance = entrance
     @refill = refill
@@ -121,8 +130,10 @@ class Pgtk::Stash
   # @return [PG::Result] Query result object
   def exec(query, params = [], result = 0)
     pure = (query.is_a?(Array) ? query.join(' ') : query).gsub(/\s+/, ' ').strip
-    if MODS_RE.match?(pure) || /(^|\s)pg_[a-z_]+\(/.match?(pure)
+    if MODS_RE.match?(pure)
       modify(pure, params, result)
+    elsif /(^|\s)pg_[a-z_]+\(/.match?(pure)
+      @pool.exec(pure, params, result)
     else
       select(pure, params, result)
     end
@@ -138,6 +149,16 @@ class Pgtk::Stash
     end
   end
 
+  # Run statements on a single connection, without a transaction.
+  #
+  # @yield [Pgtk::Stash] A stash bound to the connection
+  # @return [Object] The result of the block
+  def session
+    @pool.session do |t|
+      yield(Pgtk::Stash.new(t, stash: @stash, loog: @loog, entrance: @entrance))
+    end
+  end
+
   private
 
   def queries
@@ -145,7 +166,7 @@ class Pgtk::Stash
       {
         q: q.dup,
         c: kk.values.count,
-        p: kk.values.sum { |vv| vv[:popularity] },
+        p: kk.values.sum { |vv| vv[:popularity]&.value || 0 },
         s: kk.values.count { |vv| vv[:stale] },
         u: kk.values.map { |vv| vv[:used] }.max || Time.now
       }
@@ -222,15 +243,13 @@ class Pgtk::Stash
     tables = pure.scan(ALTS_RE).flatten
     tables.uniq!
     affected = (tables + tables.flat_map { |t| @cascades&.fetch(t, []) || [] }).uniq
-    @entrance.with_write_lock do
-      affected.each { |t| @stash[:table_inflight][t] = (@stash[:table_inflight][t] || 0) + 1 }
-    end
+    affected.each { |t| @stash[:table_inflight][t].increment }
     begin
       @pool.exec(pure, params, result).tap do
         now = Time.now
         @entrance.with_write_lock do
           affected.each do |t|
-            @stash[:table_inflight][t] -= 1
+            @stash[:table_inflight][t].decrement
             @stash[:table_mod][t] = (@stash[:table_mod][t] || 0) + 1
             @stash[:tables][t]&.each do |q|
               @stash[:queries][q]&.each_key do |key|
@@ -241,28 +260,25 @@ class Pgtk::Stash
         end
       end
     rescue StandardError
-      @entrance.with_write_lock do
-        affected.each { |t| @stash[:table_inflight][t] -= 1 }
-      end
+      affected.each { |t| @stash[:table_inflight][t].decrement }
       raise
     end
   end
 
   def select(pure, params, result)
-    key = params.join(SEPARATOR)
-    ret = @stash.dig(:queries, pure, key, :ret)
-    if ret.nil? || @stash.dig(:queries, pure, key, :stale)
+    ret = @stash.dig(:queries, pure, params, :ret)
+    if ret.nil? || @stash.dig(:queries, pure, params, :stale)
       tables = pure.scan(READS_RE).flatten
       tables.uniq!
       marks = tables.to_h { |t| [t, @stash[:table_mod][t]] }
       ret = @pool.exec(pure, params, result)
-      cache(pure, key, params, result, ret, tables, marks) unless pure.include?(' NOW() ')
+      cache(pure, params, result, ret, tables, marks) unless pure.match?(NONDETERMINISTIC)
     end
-    bump(pure, key) if @stash.dig(:queries, pure, key)
+    bump(pure, params) if @stash.dig(:queries, pure, params)
     ret
   end
 
-  def cache(pure, key, params, result, ret, tables, marks)
+  def cache(pure, params, result, ret, tables, marks)
     raise(ArgumentError, "No tables at #{pure.inspect}") if tables.empty?
     @entrance.with_write_lock do
       tables.each do |t|
@@ -270,7 +286,7 @@ class Pgtk::Stash
         @stash[:tables][t].append(pure).uniq!
       end
       @stash[:queries][pure] ||= {}
-      existing = @stash[:queries][pure][key]
+      existing = @stash[:queries][pure][params]
       stillborn = tables.any? { |t| (cur = @stash[:table_mod][t]) && cur != marks[t] }
       entry = { ret:, params:, result:, used: Time.now }
       entry[:stale] =
@@ -280,23 +296,32 @@ class Pgtk::Stash
           Time.now
         end
       entry.delete(:stale) if entry[:stale].nil?
-      @stash[:queries][pure][key] = entry
+      entry[:popularity] = (existing && existing[:popularity]) || Concurrent::AtomicFixnum.new
+      @stash[:queries][pure][params] = entry
     end
   end
 
-  def bump(pure, key)
-    @entrance.with_write_lock do
-      @stash[:queries][pure][key][:popularity] ||= 0
-      @stash[:queries][pure][key][:popularity] += 1
-      @stash[:queries][pure][key][:used] = Time.now
-    end
+  # Bump popularity and last-used time of a cached entry.
+  #
+  # This runs without the exclusive write lock: popularity is a
+  # +Concurrent::AtomicFixnum+ and +used+ is a plain assignment of an
+  # immutable value, neither of which mutates the structure of the
+  # +@stash[:queries]+ tree. Keeping it off the writer lock means a
+  # read-only workload never serializes through the writer (see #414).
+  #
+  # @return [void]
+  def bump(pure, params)
+    entry = @stash.dig(:queries, pure, params)
+    return unless entry
+    (entry[:popularity] ||= Concurrent::AtomicFixnum.new).increment
+    entry[:used] = Time.now
   end
 
   # Calculate total number of cached query results.
   #
   # @return [Integer] Total count of cached query results
   def cached
-    @entrance.with_write_lock do
+    @entrance.with_read_lock do
       @stash[:queries].values.sum { |kk| kk.values.size }
     end
   end
@@ -350,6 +375,8 @@ class Pgtk::Stash
           end
         end
       end
+    rescue StandardError => e
+      @loog.warn("Stash capper crashed: #{e.class}: #{e.message}")
     end
   end
 
@@ -361,26 +388,30 @@ class Pgtk::Stash
           evict(q) if @stash[:queries][q].empty?
         end
       end
+    rescue StandardError => e
+      @loog.warn("Stash retiree crashed: #{e.class}: #{e.message}")
     end
   end
 
-  def evict(query)
-    @stash[:queries].delete(query)
-    @stash[:tables].each_value { |list| list.delete(query) }
-    @stash[:tables].delete_if { |_, list| list.empty? }
-  end
-
   def refiller!
     Concurrent::TimerTask.execute(execution_interval: @refill, executor: @tpool) do
       ranked.each { |q| replenish(q) }
+    rescue StandardError => e
+      @loog.warn("Stash refiller crashed: #{e.class}: #{e.message}")
     end
   end
 
+  def evict(query)
+    @stash[:queries].delete(query)
+    @stash[:tables].each_value { |list| list.delete(query) }
+    @stash[:tables].delete_if { |_, list| list.empty? }
+  end
+
   def ranked
     qq =
       @entrance.with_write_lock do
         @stash[:queries]
-          .map { |k, v| [k, v.values.sum { |vv| vv[:popularity] }, v.values.any? { |vv| vv[:stale] }] }
+          .map { |k, v| [k, v.values.sum { |vv| vv[:popularity]&.value || 0 }, v.values.any? { |vv| vv[:stale] }] }
       end
     qq.select { _1[2] }.sort_by { -_1[1] }.map { _1[0] }
   end
@@ -408,7 +439,7 @@ class Pgtk::Stash
           next unless h
           next unless h[:stale] == mark
           next if pinned.any? { |t, m| @stash[:table_mod][t] != m }
-          next if tables.any? { |t| (@stash[:table_inflight][t] || 0).positive? }
+          next if tables.any? { |t| @stash[:table_inflight][t].value.positive? }
           h[:ret] = ret
           h.delete(:stale)
         end

data/lib/pgtk/version.rb

@@ -10,5 +10,5 @@ require_relative '../pgtk'
 # Copyright:: Copyright (c) 2019-2026 Yegor Bugayenko
 # License:: MIT
 module Pgtk
-  VERSION = '0.32.5' unless defined?(VERSION)
+  VERSION = '0.32.7' unless defined?(VERSION)
 end

data/lib/pgtk/wire/env.rb

@@ -29,7 +29,7 @@ class Pgtk::Wire::Env
   def initialize(var = 'DATABASE_URL', **opts)
     raise(ArgumentError, "The name of the environment variable can't be nil") if var.nil?
     @value = ENV.fetch(var, nil)
-    raise(ArgumentError, "The environment variable #{@value.inspect} is not set") if @value.nil?
+    raise(ArgumentError, "The environment variable #{var.inspect} is not set") if @value.nil?
     @opts = opts
   end
 

data/lib/pgtk/wire/yaml.rb

@@ -19,11 +19,14 @@ class Pgtk::Wire::Yaml
   #
   # @param [String] file Path to the YAML configuration file
   # @param [String] node The root node name in the YAML file containing PostgreSQL configuration
-  def initialize(file, node = 'pgsql')
+  # @param [Hash] opts Extra options forwarded to +PG.connect+ (e.g. +sslmode+,
+  #   +connect_timeout+, +keepalives+). These override values from the YAML file.
+  def initialize(file, node = 'pgsql', **opts)
     raise(ArgumentError, "The name of the file can't be nil") if file.nil?
     @file = file
     raise(ArgumentError, "The name of the node in the YAML file can't be nil") if node.nil?
     @node = node
+    @opts = opts
   end
 
   # Create a new connection to PostgreSQL server.
@@ -36,7 +39,9 @@ class Pgtk::Wire::Yaml
       port: cfg[@node]['port'],
       dbname: cfg[@node]['dbname'],
       user: cfg[@node]['user'],
-      password: cfg[@node]['password']
+      password: cfg[@node]['password'],
+      **cfg[@node].except(*%w[host port dbname user password url]).transform_keys(&:to_sym),
+      **@opts
     ).connection
   end
 end

data/pgtk.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |s|
   s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
   s.rdoc_options = ['--charset=UTF-8']
   s.extra_rdoc_files = ['README.md', 'LICENSE.txt']
-  s.add_dependency('backtrace', '~>0.4')
+  s.add_dependency('cgi', '~>0.0')
   s.add_dependency('concurrent-ruby', '~>1.3')
   s.add_dependency('donce', '~>0.0')
   s.add_dependency('ellipsized', '~>0.3')

data/resources/pom.xml

@@ -10,7 +10,7 @@
   <version>0.0.0</version>
   <packaging>pom</packaging>
   <properties>
-    <postgresql.version>42.7.11</postgresql.version>
+    <postgresql.version>42.7.12</postgresql.version>
     <liquibase.version>5.0.3</liquibase.version>
   </properties>
   <dependencies>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgtk
 version: !ruby/object:Gem::Version
-  version: 0.32.5
+  version: 0.32.7
 platform: ruby
 authors:
 - Yegor Bugayenko
@@ -10,19 +10,19 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: backtrace
+  name: cgi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.0'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement