pgtk 0.31.1 → 0.31.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a15b5d36eab5407bca78c591056966cee9b90167e5bfa0cc98fa36984801622a
-  data.tar.gz: bd201e64d30a88836337d86b4b3d202b708109de1676ce5d83593df8f4e4ace4
+  metadata.gz: ce069bed0f29101349d2617ad2ae7c51f4f03e6b6a4b800d717bf4ac75bb533f
+  data.tar.gz: 81e34a18fdf26fea4545e33f5c554af8b17f74f75e0a8efe450dea16fa13df49
 SHA512:
-  metadata.gz: 8b58b179b7c85ff2183d7c909da288f9a4be5c67bbe8040350c8706098bac8ccbfe05010d638f28db67cf70b1434744abc6667008f1fcc32bdc6aaa3a4cb1fd8
-  data.tar.gz: 0da90a8d6b61c07125bab269833149217f625caadbfbb8e12363ac84f84efa36e321fb6ec18f5b12c0b1bb9dfdab42ad74086cb6300b9fb0b122e2a52e9384cf
+  metadata.gz: fea29eaaef7f045eec87fd114d5ba55782d50332333169ab30012bbf9e221dd2c3ef1be57af808f4aa1986b5356e27a8b25ce144c52bcaad3ad8329772eb81a2
+  data.tar.gz: c84f1647c650b98ff6e34e752184a922ec74c285c55dcfa26714c50280a09bb5cf6bf3ff6e40dee0c5f03a39aa0aa30396ad7ffd30b05859d981eb67c2697437

data/Gemfile.lock

@@ -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/pool.rb

@@ -343,16 +343,27 @@ class Pgtk::Pool
 
   def connect
     conn = @pool.pop
+    conn = renew(conn) if dead?(conn)
     begin
       yield(conn)
     rescue StandardError => e
-      conn = renew(conn)
+      begin
+        conn = renew(conn)
+      rescue StandardError => re
+        @log.warn("Failed to renew connection after #{e.message}: #{re.message}")
+      end
       raise(e)
     ensure
       @pool.push(conn)
     end
   end
 
+  def dead?(conn)
+    conn.finished? || conn.status == PG::Constants::CONNECTION_BAD
+  rescue StandardError
+    true
+  end
+
   def renew(conn)
     begin
       conn.close unless conn.finished?

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

metadata

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