pgtk 0.31.0 → 0.31.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bce43b422e6baef8427e57d0635f613f2af93eea4a2f783b2fa62c85520b565
-  data.tar.gz: ea73771e5ea9c4f17919d257316d548280cf623e77f50266f6283e8f0ed71d8b
+  metadata.gz: b7db2cc332dfccb4c405f590cc7aa64ffc55d1aa916aea3c0ea68379208c2568
+  data.tar.gz: c7a03b2c8b6ccf2b931b1ab4d16bf83f352edeb0099c1d5fcc8f21a5f274a789
 SHA512:
-  metadata.gz: 908b1a4e77e794a5d91aae82169969bac770d3638771356f65b7f5ac7b2b490b14a99f5cc7caba4e63e99e09678d423f51944faf52f6c368040a6f4d55eb9b78
-  data.tar.gz: 5a15b9c10cb8f238b00888d761436633d8381e7b52c731af3c8fa67c5c4c48cd27274dc3975d9b3eaf612f189ffa871c026eca758991924b4d0aa3b3a4b9099a
+  metadata.gz: d0e7ca8dc2192a5acb274b9e4b02fda11fdfaf471fe607c7d5d8ac0cf85cd8b527bb35f3de93f271102ba4b483a285452df5d6e1f308df8f503e987b42b10197
+  data.tar.gz: d028000b4d1e869d9766105a7706f8b415f012a1c6f3254f2c2bdd6bb8578b97f27fd22f317cc06f7609ca3b79667814d60ca1713b21be3145a51b1b41e5d752

data/Gemfile.lock

@@ -42,7 +42,7 @@ GEM
     loog (0.8.0)
       ellipsized
       logger (~> 1.0)
-    minitest (6.0.4)
+    minitest (6.0.5)
       drb (~> 2.0)
       prism (~> 1.5)
     minitest-mock (5.27.0)
@@ -108,7 +108,7 @@ GEM
     rubocop-ast (1.49.1)
       parser (>= 3.3.7.2)
       prism (~> 1.7)
-    rubocop-elegant (0.0.18)
+    rubocop-elegant (0.0.20)
       lint_roller (~> 1.1)
       rubocop (~> 1.75)
     rubocop-minitest (0.39.1)
@@ -142,9 +142,9 @@ GEM
       unicode-emoji (~> 4.1)
     unicode-emoji (4.2.0)
     waitutil (0.2.1)
-    xcop (0.8.0)
+    xcop (0.9.0)
       differ (~> 0.1.2)
-      nokogiri (~> 1.10)
+      nokogiri (~> 1.8)
       rainbow (~> 3.0)
       slop (~> 4.4)
     yard (0.9.43)

data/lib/pgtk/impatient.rb

@@ -119,13 +119,19 @@ class Pgtk::Impatient
     end
   end
 
-  # Run a transaction with a timeout for each query.
+  # Run a transaction with a timeout for each query and for idle time inside
+  # the transaction. If the transaction stays in the +INTRANS+ state (idle
+  # inside transaction) for longer than the configured timeout, PostgreSQL
+  # terminates the session, which frees locks and releases the connection
+  # slot back to the pool.
   #
   # @yield [Pgtk::Impatient] Yields an impatient transaction
   # @return [Object] Result of the block
   def transaction
     @pool.transaction do |t|
-      t.exec("SET LOCAL statement_timeout = #{Integer((@timeout * 1000).to_s, 10)}")
+      ms = Integer((@timeout * 1000).to_s, 10)
+      t.exec("SET LOCAL statement_timeout = #{ms}")
+      t.exec("SET LOCAL idle_in_transaction_session_timeout = #{ms}")
       yield(Pgtk::Impatient.new(t, @timeout))
     end
   end

data/lib/pgtk/stash.rb

@@ -57,7 +57,7 @@ class Pgtk::Stash
   # @param [Concurrent::ReentrantReadWriteLock] entrance Read-write lock for thread-safe access
   def initialize(
     pool,
-    stash: { queries: {}, tables: {} },
+    stash: { queries: {}, tables: {}, table_mod: {} },
     loog: Loog::NULL,
     entrance: Concurrent::ReentrantReadWriteLock.new,
     refill: 16,
@@ -71,6 +71,7 @@ class Pgtk::Stash
   )
     @pool = pool
     @stash = stash
+    @stash[:table_mod] ||= {}
     @loog = loog
     @entrance = entrance
     @refill = refill
@@ -216,11 +217,13 @@ class Pgtk::Stash
     tables = pure.scan(ALTS_RE).flatten
     tables.uniq!
     ret = @pool.exec(pure, params, result)
+    now = Time.now
     @entrance.with_write_lock do
       tables.each do |t|
+        @stash[:table_mod][t] = now
         @stash[:tables][t]&.each do |q|
           @stash[:queries][q]&.each_key do |key|
-            @stash[:queries][q][key][:stale] = Time.now
+            @stash[:queries][q][key][:stale] = now
           end
         end
       end
@@ -233,16 +236,17 @@ class Pgtk::Stash
     ret = @stash.dig(:queries, pure, key, :ret)
     if ret.nil? || @stash.dig(:queries, pure, key, :stale)
       mark = @stash.dig(:queries, pure, key, :stale)
+      tables = pure.scan(/(?<=^|\s)(?:FROM|JOIN) ([a-z_]+)(?=\s|;|$)/).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, mark) unless pure.include?(' NOW() ')
+      cache(pure, key, params, result, ret, mark, tables, marks) unless pure.include?(' NOW() ')
     end
     bump(pure, key) if @stash.dig(:queries, pure, key)
     ret
   end
 
-  def cache(pure, key, params, result, ret, mark)
-    tables = pure.scan(/(?<=^|\s)(?:FROM|JOIN) ([a-z_]+)(?=\s|;|$)/).flatten
-    tables.uniq!
+  def cache(pure, key, params, result, ret, mark, tables, marks)
     raise(ArgumentError, "No tables at #{pure.inspect}") if tables.empty?
     @entrance.with_write_lock do
       tables.each do |t|
@@ -252,8 +256,9 @@ class Pgtk::Stash
       @stash[:queries][pure] ||= {}
       existing = @stash[:queries][pure][key]
       stale = existing && existing[:stale]
+      stillborn = tables.any? { |t| (cur = @stash[:table_mod][t]) && cur != marks[t] }
       entry = { ret:, params:, result:, used: Time.now }
-      entry[:stale] = stale if stale && stale != mark
+      entry[:stale] = stale == mark ? Time.now : stale if (stale && stale != mark) || stillborn
       @stash[:queries][pure][key] = entry
     end
   end
@@ -294,7 +299,7 @@ class Pgtk::Stash
             m = @stash[:queries][q].values.map { |h| h[:used] }.min
             next unless m
             @stash[:queries][q].delete_if { |_, h| h[:used] == m }
-            @stash[:queries].delete_if { |_, kk| kk.empty? }
+            evict(q) if @stash[:queries][q].empty?
           end
         end
       end
@@ -306,12 +311,18 @@ class Pgtk::Stash
       @entrance.with_write_lock do
         @stash[:queries].each_key do |q|
           @stash[:queries][q].delete_if { |_, h| h[:used] < Time.now - @retire }
-          @stash[:queries].delete_if { |_, kk| kk.empty? }
+          evict(q) if @stash[:queries][q].empty?
         end
       end
     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) }
@@ -328,16 +339,22 @@ class Pgtk::Stash
   end
 
   def replenish(query)
-    @entrance.with_write_lock { @stash[:queries][query].keys }.each do |k|
-      next unless @stash[:queries][query][k][:stale]
-      next if @stash[:queries][query][k][:stale] > Time.now - @delay
+    snapshot =
+      @entrance.with_read_lock do
+        @stash[:queries][query]&.filter_map do |k, h|
+          next unless h[:stale]
+          next if h[:stale] > Time.now - @delay
+          [k, h[:params], h[:result], h[:stale]]
+        end
+      end
+    return unless snapshot
+    snapshot.each do |k, params, result, mark|
       next if @tpool.queue_length >= @maxqueue
       @tpool.post do
-        h = @stash[:queries][query][k]
-        mark = h[:stale]
-        ret = @pool.exec(query, h[:params], h[:result])
+        ret = @pool.exec(query, params, result)
         @entrance.with_write_lock do
-          h = @stash[:queries][query][k]
+          h = @stash[:queries][query]&.dig(k)
+          next unless h
           if h[:stale] == mark
             h[:ret] = ret
             h.delete(:stale)

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.31.0' unless defined?(VERSION)
+  VERSION = '0.31.2' unless defined?(VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgtk
 version: !ruby/object:Gem::Version
-  version: 0.31.0
+  version: 0.31.2
 platform: ruby
 authors:
 - Yegor Bugayenko