pgtk 0.19.1 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 851e2e812bbf8ed39a1942d5cbe6a76814969a1599cc0e48cfa6e9e3b3ed8b6e
-  data.tar.gz: 3736d4d8eceebdfabc61bff42fc7c3dfc2628d4ea639af2da4661e7ffbf4eea6
+  metadata.gz: 8177f7980e33d9ef9a42fa130f732f1e8109175c417798e4e1046b0f72ae0a85
+  data.tar.gz: 43fca371b69dd3aaf154fca4b2d912edd6fd4709c6c6f09bc525749c2023fa92
 SHA512:
-  metadata.gz: 81cff65a765e54e42e30f1d8c0aa029b88fa47fefce482e26d33650ec612452f51421624faf1591e144e8ca64bfdc427bee9628728cdb6a9a31b38e8c06a0c74
-  data.tar.gz: 593e47e81f8b412ebb34083f921d414d33dc3a3f4b3ea59126a39ca1d200046b7984910a572f2303764d02640976e450a0af1de2d2cbed7d6e735a2e82e92d10
+  metadata.gz: 9cdddfb02085dfa5b48209aa0f4aace1825ba91d60f44fa9c5d736b78b8180086cecad8e25894f2b0cd16a3156c3e497af412ba67f0fcecf11684ae798f75872
+  data.tar.gz: f94264b6a3610ca388156430feb567ac405d6b785a92a15c4557b153b3edbbb4c22280c306cac3f0ed7b4b5e8792c93d423da8854c74078d6b1b851da5fe2ebc

data/Gemfile.lock

@@ -58,7 +58,7 @@ GEM
       loog (> 0)
       tago (> 0)
     racc (1.8.1)
-    rack (3.2.3)
+    rack (3.2.4)
     rainbow (3.1.1)
     rake (13.3.1)
     random-port (0.7.6)

data/Rakefile

@@ -30,6 +30,7 @@ require 'yard'
 desc 'Build Yard documentation'
 YARD::Rake::YardocTask.new do |t|
   t.files = ['lib/**/*.rb']
+  t.options = ['--fail-on-warning']
 end
 
 require 'rubocop/rake_task'

data/lib/pgtk/impatient.rb

@@ -74,6 +74,16 @@ class Pgtk::Impatient
     @pool.version
   end
 
+  # Convert internal state into text.
+  def dump
+    [
+      @pool.dump,
+      '',
+      "Pgtk::Impatient (timeout=#{@timeout}s):",
+      @off.map { |re| "  #{re}" }
+    ].join("\n")
+  end
+
   # Execute a SQL query with a timeout.
   #
   # @param [String] sql The SQL query with params inside (possibly)

data/lib/pgtk/pool.rb

@@ -54,7 +54,7 @@ class Pgtk::Pool
   def initialize(wire, log: Loog::NULL)
     @wire = wire
     @log = log
-    @pool = Queue.new
+    @pool = IterableQueue.new
   end
 
   # Get the version of PostgreSQL server.
@@ -64,6 +64,19 @@ class Pgtk::Pool
     @version ||= exec('SHOW server_version')[0]['server_version'].split[0]
   end
 
+  # Get as much details about it as possible.
+  #
+  # @return [String] Summary of inner state
+  def dump
+    [
+      "PgSQL version: #{version}",
+      "#{@pool.size} connections:",
+      @pool.map do |c|
+        "  ##{c.backend_pid} #{c.pipeline_status} #{c.status} #{c.transaction_status}"
+      end
+    ].flatten.join("\n")
+  end
+
   # Start it with a fixed number of connections. The amount of connections
   # is specified in +max+ argument and should be big enough to handle
   # the amount of parallel connections you may have to the database. However,
@@ -164,6 +177,46 @@ class Pgtk::Pool
     end
   end
 
+  # Thread-safe queue implementation that supports iteration.
+  # Unlike Ruby's Queue class, this implementation allows safe iteration
+  # over all elements while maintaining thread safety for concurrent access.
+  #
+  # This class is used internally by Pool to store database connections
+  # and provide the ability to iterate over them for inspection purposes.
+  class IterableQueue
+    def initialize
+      @items = []
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+    end
+
+    def <<(item)
+      @mutex.synchronize do
+        @items << item
+        @condition.signal
+      end
+    end
+
+    def pop
+      @mutex.synchronize do
+        @condition.wait(@mutex) while @items.empty?
+        @items.shift
+      end
+    end
+
+    def size
+      @mutex.synchronize do
+        @items.size
+      end
+    end
+
+    def map(&)
+      @mutex.synchronize do
+        @items.map(&)
+      end
+    end
+  end
+
   # A temporary class to execute a single SQL request.
   class Txn
     def initialize(conn, log)

data/lib/pgtk/retry.rb

@@ -63,24 +63,32 @@ class Pgtk::Retry
     @pool.version
   end
 
+  # Convert internal state into text.
+  def dump
+    [
+      @pool.dump,
+      '',
+      "Pgtk::Retry (attempts=#{@attempts})"
+    ].join("\n")
+  end
+
   # Execute a SQL query with automatic retry for SELECT queries.
   #
   # @param [String] sql The SQL query with params inside (possibly)
-  # @param [Array] args List of arguments
   # @return [Array] Result rows
-  def exec(sql, *args)
+  def exec(sql, *)
     query = sql.is_a?(Array) ? sql.join(' ') : sql
     if query.strip.upcase.start_with?('SELECT')
       attempt = 0
       begin
-        @pool.exec(sql, *args)
+        @pool.exec(sql, *)
       rescue StandardError => e
         attempt += 1
         raise e if attempt >= @attempts
         retry
       end
     else
-      @pool.exec(sql, *args)
+      @pool.exec(sql, *)
     end
   end
 
@@ -88,7 +96,7 @@ class Pgtk::Retry
   #
   # @yield [Object] Yields the transaction object
   # @return [Object] Result of the block
-  def transaction(&block)
-    @pool.transaction(&block)
+  def transaction(&)
+    @pool.transaction(&)
   end
 end

data/lib/pgtk/spy.rb

@@ -62,14 +62,22 @@ class Pgtk::Spy
     @pool.version
   end
 
+  # Convert internal state into text.
+  def dump
+    [
+      @pool.dump,
+      '',
+      'Pgtk::Spy'
+    ].join("\n")
+  end
+
   # Execute a SQL query and track its execution.
   #
   # @param [String] sql The SQL query with params inside (possibly)
-  # @param [Array] args List of arguments
   # @return [Array] Result rows
-  def exec(sql, *args)
+  def exec(sql, *)
     start = Time.now
-    ret = @pool.exec(sql, *args)
+    ret = @pool.exec(sql, *)
     @block&.call(sql.is_a?(Array) ? sql.join(' ') : sql, Time.now - start)
     ret
   end

data/lib/pgtk/stash.rb

@@ -28,42 +28,72 @@ class Pgtk::Stash
   ALTS = ['UPDATE', 'INSERT INTO', 'DELETE FROM', 'TRUNCATE', 'ALTER TABLE', 'DROP TABLE'].freeze
   ALTS_RE = Regexp.new("(?<=^|\\s)(?:#{ALTS.join('|')})\\s([a-z]+)(?=[^a-z]|$)")
 
-  private_constant :MODS, :ALTS, :MODS_RE, :ALTS_RE
+  SEPARATOR = ' --%*@#~($-- '
+
+  private_constant :MODS, :ALTS, :MODS_RE, :ALTS_RE, :SEPARATOR
 
   # Initialize a new Stash with query caching.
   #
-  # @param [Object] pgsql PostgreSQL connection object
+  # @param [Object] pool Original object
   # @param [Hash] stash Optional existing stash to use (default: new empty stash)
   # @option [Hash] queries Internal cache data (default: {})
   # @option [Hash] tables Internal cache data (default: {})
   # @option [Concurrent::ReentrantReadWriteLock] entrance Lock for write internal state
-  # @option [Concurrent::AtomicBoolean] start_refresher Latch for start timers once
-  # @param [Integer] refresh Interval in seconds for recalculate stale queries
+  # @option [Concurrent::AtomicBoolean] launched Latch for start timers once
+  # @param [Integer] refill_interval Interval in seconds for recalculate stale queries
   # @param [Integer] top Number of queries to recalculate
   # @param [Integer] threads Number of threads in threadpool
   # @param [Loog] loog Logger for debugging (default: null logger)
   def initialize(
-    pgsql,
+    pool,
     stash = {
       queries: {},
       tables: {},
       entrance: Concurrent::ReentrantReadWriteLock.new,
-      start_refresher: Concurrent::AtomicBoolean.new(false)
+      launched: Concurrent::AtomicBoolean.new(false)
     },
-    refresh: 5,
+    refill_interval: 5,
     top: 100,
     threads: 5,
     loog: Loog::NULL
   )
-    @pgsql = pgsql
+    @pool = pool
     @stash = stash
     @entrance = stash[:entrance]
-    @refresh = refresh
+    @refill_interval = refill_interval
     @top = top
     @threads = threads
     @loog = loog
   end
 
+  # Get the PostgreSQL server version.
+  # @return [String] Version string of the database server
+  def version
+    @pool.version
+  end
+
+  # Convert internal state into text.
+  def dump
+    qq =
+      @stash[:queries].map do |k, v|
+        [
+          k.dup, # the query
+          v.values.count, # how many keys?
+          v.values.sum { |vv| vv[:popularity] }, # total popularity of all keys
+          v.values.count { |vv| vv[:stale] } # how many stale keys?
+        ]
+      end
+    [
+      @pool.dump,
+      '',
+      "Pgtk::Stash (refill_interval=#{@refill_interval}s, top=#{@top}q, threads=#{@threads}t):",
+      "  #{'not ' unless @stash[:launched]}launched",
+      "  #{@stash[:tables].count} tables in cache",
+      "  #{@stash[:queries].count} queries in cache:",
+      qq.sort_by { -_1[2] }.take(20).map { |a| "    #{a[1]}/#{a[2]}p/#{a[3]}s: #{a[0]}" }
+    ].join("\n")
+  end
+
   # Execute a SQL query with optional caching.
   #
   # Read queries are cached, while write queries bypass the cache and invalidate related entries.
@@ -76,26 +106,25 @@ class Pgtk::Stash
     pure = (query.is_a?(Array) ? query.join(' ') : query).gsub(/\s+/, ' ').strip
     if MODS_RE.match?(pure) || /(^|\s)pg_[a-z_]+\(/.match?(pure)
       tables = pure.scan(ALTS_RE).map(&:first).uniq
-      ret = @pgsql.exec(pure, params, result)
+      ret = @pool.exec(pure, params, result)
       @entrance.with_write_lock do
         tables.each do |t|
           @stash[:tables][t]&.each do |q|
             @stash[:queries][q].each_key do |key|
-              @stash[:queries][q][key]['stale'] = true
+              @stash[:queries][q][key][:stale] = true
             end
           end
         end
       end
     else
-      key = params.map(&:to_s).join(' -*&%^- ')
-      @entrance.with_write_lock { @stash[:queries][pure] ||= {} }
-      ret = @stash.dig(:queries, pure, key, 'ret')
-      if ret.nil? || @stash.dig(:queries, pure, key, 'stale')
-        ret = @pgsql.exec(pure, params, result)
+      key = params.map(&:to_s).join(SEPARATOR)
+      ret = @stash.dig(:queries, pure, key, :ret)
+      if ret.nil? || @stash.dig(:queries, pure, key, :stale)
+        ret = @pool.exec(pure, params, result)
         unless pure.include?(' NOW() ')
           @entrance.with_write_lock do
             @stash[:queries][pure] ||= {}
-            @stash[:queries][pure][key] = { 'ret' => ret, 'params' => params, 'result' => result }
+            @stash[:queries][pure][key] = { ret:, params:, result: }
             tables = pure.scan(/(?<=^|\s)(?:FROM|JOIN) ([a-z_]+)(?=\s|$)/).map(&:first).uniq
             tables.each do |t|
               @stash[:tables][t] = [] if @stash[:tables][t].nil?
@@ -105,7 +134,12 @@ class Pgtk::Stash
           end
         end
       end
-      count(pure, key)
+      if @stash.dig(:queries, query, key)
+        @entrance.with_write_lock do
+          @stash[:queries][query][key][:popularity] ||= 0
+          @stash[:queries][query][key][:popularity] += 1
+        end
+      end
     end
     ret
   end
@@ -117,10 +151,10 @@ class Pgtk::Stash
   # @yield [Pgtk::Stash] A stash connected to the transaction
   # @return [Object] The result of the block
   def transaction
-    @pgsql.transaction do |t|
+    @pool.transaction do |t|
       yield Pgtk::Stash.new(
         t, @stash,
-        refresh: @refresh,
+        refill_interval: @refill_interval,
         top: @top,
         threads: @threads,
         loog: @loog
@@ -129,73 +163,47 @@ class Pgtk::Stash
   end
 
   # Start a new connection pool with the given arguments.
-  #
-  # @param args Arguments to pass to the underlying pool's start method
   # @return [Pgtk::Stash] A new stash that shares the same cache
-  def start(*args)
-    start_refresher
+  def start(*)
+    launch!
     Pgtk::Stash.new(
-      @pgsql.start(*args), @stash,
-      refresh: @refresh,
+      @pool.start(*), @stash,
+      refill_interval: @refill_interval,
       top: @top,
       threads: @threads,
       loog: @loog
     )
   end
 
-  # Get the PostgreSQL server version.
-  #
-  # @return [String] Version string of the database server
-  def version
-    @pgsql.version
-  end
-
-  # Get statistics on the most used queries
-  #
-  # @return [Array<Array<String, Integer>>] Array of query and hits in desc hits order
-  def stats
-    @stash[:queries].map { |k, v| [k.dup, v.values.sum { |vv| vv['count'] }] }.sort_by { -_1[1] }
-  end
-
   private
 
-  def count(query, key)
-    return if @stash.dig(:queries, query, key).nil?
-    @entrance.with_write_lock do
-      @stash[:queries][query][key]['count'] ||= 0
-      @stash[:queries][query][key]['count'] += 1
-    end
-  end
-
-  def start_refresher
-    raise 'Cannot start cache refresh multiple times on same cache data' unless @stash[:start_refresher].make_true
+  def launch!
+    raise 'Cannot launch multiple times on same cache data' unless @stash[:launched].make_true
     Concurrent::FixedThreadPool.new(@threads).then do |threadpool|
-      Concurrent::TimerTask.execute(execution_interval: 24 * 60 * 60, executor: threadpool) do
+      Concurrent::TimerTask.execute(execution_interval: 60 * 60, executor: threadpool) do
         @entrance.with_write_lock do
           @stash[:queries].each_key do |q|
             @stash[:queries][q].each_key do |k|
-              @stash[:queries][q][k]['count'] = 0
+              @stash[:queries][q][k][:popularity] = 0
             end
           end
         end
       end
-      Concurrent::TimerTask.execute(execution_interval: @refresh, executor: threadpool) do
+      Concurrent::TimerTask.execute(execution_interval: @refill_interval, executor: threadpool) do
         @stash[:queries]
-          .map { |k, v| [k, v.values.sum { |vv| vv['count'] }, v.values.any? { |vv| vv['stale'] }] }
+          .map { |k, v| [k, v.values.sum { |vv| vv[:popularity] }, v.values.any? { |vv| vv[:stale] }] }
           .select { _1[2] }
           .sort_by { -_1[1] }
           .first(@top)
           .each do |a|
           q = a[0]
           @stash[:queries][q].each_key do |k|
-            next unless @stash[:queries][q][k]['stale']
+            next unless @stash[:queries][q][k][:stale]
             threadpool.post do
-              params = @stash[:queries][q][k]['params']
-              result = @stash[:queries][q][k]['result']
-              ret = @pgsql.exec(q, params, result)
               @entrance.with_write_lock do
-                @stash[:queries][q] ||= {}
-                @stash[:queries][q][k] = { 'ret' => ret, 'params' => params, 'result' => result, 'count' => 1 }
+                h = @stash[:queries][q][k]
+                h[:stale] = false
+                h[:ret] = @pool.exec(q, h[:params], h[:result])
               end
             end
           end

data/lib/pgtk/version.rb

@@ -11,5 +11,5 @@ require_relative '../pgtk'
 # License:: MIT
 module Pgtk
   # Current version of the library.
-  VERSION = '0.19.1'
+  VERSION = '0.20.0'
 end

data/lib/pgtk/wire.rb

@@ -72,7 +72,7 @@ class Pgtk::Wire::Env
     Pgtk::Wire::Direct.new(
       host: uri.host,
       port: uri.port,
-      dbname: uri.path[1..-1],
+      dbname: uri.path[1..],
       user: uri.userinfo.split(':')[0],
       password: uri.userinfo.split(':')[1]
     ).connection

data/pgtk.gemspec

@@ -10,7 +10,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require_relative 'lib/pgtk/version'
 Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
-  s.required_ruby_version = '>= 2.3'
+  s.required_ruby_version = '>= 3.2'
   s.name = 'pgtk'
   s.version = Pgtk::VERSION
   s.license = 'MIT'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgtk
 version: !ruby/object:Gem::Version
-  version: 0.19.1
+  version: 0.20.0
 platform: ruby
 authors:
 - Yegor Bugayenko
@@ -180,7 +180,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="