pg_pipeline 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 750bfa3d5740056066f5a3543e747f02701132ab941aabbd828d25ece368b1df
-  data.tar.gz: f822719ac13016e6a5e8fc373f6fcaf625cd97cc128cf9322a1231228d20ad40
+  metadata.gz: 7135257ec52d199f4a7e0d3666909eebd8effa277f7efe80d27ca8ff00717f93
+  data.tar.gz: 8f3b976cc4b9f8400439a1504bbad9a019865a88a7f41e6556907ba649587c80
 SHA512:
-  metadata.gz: d7ea51781dc5150133a1f04d8c65ac2b57bc39df6de98f34534e6e490359dcb1b4f19684c2a950f6a22e138ef2d1ca17c4e034df961140afbc4f37d1dab3c76a
-  data.tar.gz: 45c4e56417cfa97147db391f2150dba6c5dc0e01f957a373429ef5f6dd7c6ee4baa50973e0a93c179f480bbf3ad79c20d5a501b4e72e705a743cb16b921b4607
+  metadata.gz: 90422fd9a948509c2e53b9058d052a822e76f303a736a39488a0870b6fa903d6c1b2b8248e00649269a63ed606a9a8d04b1c2c081cf0f2b89e81000af8a36e54
+  data.tar.gz: fa76f361560fa078903685d69de81600b8337509b8f37b89cd93fdfdc71ebc3953180edf8487b4aa24d79d521237ef98bc727cde48ca959acb41c0d589749999

data/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## [0.2.3] - 2026-07-30
+
+Performance-focused release based on CPU profiles from the live pipeline
+workload. It removes redundant libpq polling, adds an explicit prepared-
+statement hot path, and trims several per-query control-plane costs without
+changing the failure model.
+
+### Added
+
+- `Client#prepare(name, sql, param_types = nil)` prepares immutable SQL on every
+  currently live pipeline connection and returns a `PreparedStatement` handle.
+- `PreparedStatement#query(params = [])` executes through
+  `send_query_prepared`, avoiding repeated Parse/Describe work for hot SQL.
+- Replacement pipeline connections replay the registered prepared-statement
+  catalog before becoming available, including registrations that race with a
+  reconnect.
+- Prepared-statement unit and live integration coverage, including execution
+  across multiple drivers and automatic re-prepare after reconnect.
+
+### Performance
+
+- The connection owner drains results only after `consume_input` actually read
+  a readable socket event. Removed unconditional pre/post-dispatch drain passes
+  that repeatedly called `PQisBusy` without new input.
+- A blocked `PQflush` is retried by the writer watcher instead of again on every
+  unrelated owner event. Newly queued output remains buffered in libpq until the
+  socket becomes writable.
+- Driver selection is now one circular least-load pass: each available driver's
+  `load` is read once and equal-load ties rotate from the selected slot.
+- The normalized SQL guard mode is reused on the query hot path instead of
+  coercing and validating it for every request.
+- Already-frozen SQL strings and frozen string bind values are reused rather
+  than duplicated; mutable caller input is still snapshotted before submission.
+- Prepared-only metadata lives on internal request subclasses, so ordinary
+  query requests do not grow extra instance variables for the new API.
+- The throughput and A/B harnesses explicitly clear every result and support
+  `PREPARED=1`, preparing both pipeline and baseline clients for a fair hot-path
+  comparison.
+
+### Semantics
+
+- Prepared statements are explicit client-scoped handles, not an automatic
+  unbounded SQL cache. The SQL guard runs once during registration.
+- Failed registration is removed from the reconnect catalog. Successfully
+  prepared but unreachable internal names may remain on already-prepared
+  physical connections until those connections close.
+- Multiplexed prepared handles live for the lifetime of the client; this release
+  intentionally does not add a concurrent `DEALLOCATE` API.
+
 ## [0.2.2] - 2026-07-30
 
 Lifecycle-hardening release. Fixes five pool/task-ownership defects surfaced by

data/DESIGN.md

@@ -51,10 +51,13 @@ sync_get_result
 `is_busy` is only a readiness predicate: false means the next
 `sync_get_result` will not block. It is not a request boundary.
 
-The owner also checks `is_busy` opportunistically before going back to sleep,
-not only after a socket-readable notification. PostgreSQL's own
-`libpq_pipeline.c` does the same because libpq can synthesize an aborted-pipeline
-result locally without making the socket newly readable.
+The owner calls `consume_input` on a socket-readable event and then drains until
+`is_busy` becomes true or the in-flight FIFO is empty. A drain pass exhausts all
+currently buffered results, including locally represented pipeline-aborted and
+pipeline-sync statuses. Request, writable and bookkeeping events therefore do
+not poll `is_busy` again: without a new `consume_input` they cannot reveal new
+server input, and the redundant Ruby-to-C calls were the largest control-plane
+CPU hot spot in profiling.
 
 ## 4. Protocol/FIFO model
 
@@ -112,6 +115,21 @@ Anything stateful goes through an exclusive pinned connection:
 - `Client#session` — no implicit BEGIN;
 - `Client#transaction` — BEGIN/COMMIT/ROLLBACK.
 
+The one deliberate exception is `Client#prepare`, which is not an arbitrary
+session mutation exposed to callers. It registers immutable SQL in a
+client-owned catalog and prepares the same generated physical name on every
+pipeline connection. The returned `PreparedStatement` handle can then use
+`send_query_prepared` through the normal FIFO protocol. A replacement connection
+replays the full catalog before it becomes available, so routing never selects a
+driver that lacks a successfully registered handle.
+
+Registration is explicit: there is no unbounded automatic SQL cache. A failed
+registration is removed from the reconnect catalog; statements that had already
+been prepared on another connection may remain there under an unreachable
+generated name until that connection is replaced or closed. Version 0.2.3 does
+not expose `DEALLOCATE` for multiplexed handles. Server-side plan invalidation is
+reported as the ordinary request-local `QueryError`.
+
 Pinned connections are opened lazily up to `pinned_size`; a query-only process
 does not reserve an otherwise idle second pool at startup. Before a pinned
 physical connection is reused, the pool makes sure it is outside an explicit
@@ -250,6 +268,8 @@ chunked-rows, non-blocking cancel), never a floor.
   (`cancel_pinned_on_abort: true`); it does not force-close the socket if the
   backend ignores cancel.
 - No streaming/single-row/chunked-row result API.
+- No multiplexed prepared-statement deallocation API; registered handles live
+  for the lifetime of the client.
 - No cross-thread/reactor sharing; `Client` rejects use from a different thread or Fiber scheduler.
 - `SessionGuard` is policy/ergonomics, not a security boundary. `:strict` adds a
   precise denylist (`nextval`/`setval`/`pg_export_snapshot`, …) without the old

data/README.md

@@ -62,6 +62,35 @@ end
 `Client.open` manages the pool lifecycle. `db.query` is fiber-safe and multiplexed —
 every fiber yields while waiting, the event loop stays unblocked.
 
+### Multiplexed prepared statements
+
+For repeated SQL, prepare it once on every pipeline connection and execute the
+returned immutable handle:
+
+```ruby
+by_id = db.prepare(
+  "user_by_id",
+  "SELECT id, email, name FROM users WHERE id = $1",
+  [23] # optional PostgreSQL parameter OIDs
+)
+
+result = by_id.query([42])
+begin
+  p result.first
+ensure
+  result.clear
+end
+```
+
+`Client#prepare` returns only after the statement is ready on every currently
+live pipeline connection. Replacement connections automatically prepare the
+registered catalog before they begin accepting requests. The logical name is
+client-local; the gem uses private generated server names on its owned connections.
+
+Prepared handles are intentionally explicit rather than an unbounded automatic
+SQL cache. The SQL guard runs once at preparation time, while each execution
+still snapshots its bind values before submission.
+
 ### Transactions
 
 ```ruby
@@ -84,7 +113,7 @@ db.transaction do |tx|
 end
 ```
 
-### Session (DDL, LISTEN, SET, prepared statements)
+### Session (DDL, LISTEN, SET, connection-local prepared statements)
 
 ```ruby
 db.session do |s|
@@ -119,6 +148,7 @@ db.stats
 # => {
 #   pipeline: { size: 4, live: 4, drivers: [{load: 3, in_flight: 2, ...}, ...] },
 #   pinned:   { size: 2, active: 1, free: 1 },
+#   prepared_statements: 1,
 #   reconnects: 0
 # }
 ```

data/lib/pg_pipeline/client.rb

@@ -5,6 +5,7 @@ require "async"
 require_relative "errors"
 require_relative "pool"
 require_relative "request"
+require_relative "prepared_statement"
 require_relative "session_guard"
 require_relative "session"
 require_relative "transaction"
@@ -27,6 +28,7 @@ module PgPipeline
 
     def start(parent: Async::Task.current) = ClientOps.start(self, parent)
     def query(sql, params = []) = ClientOps.query(self, sql, params)
+    def prepare(name, sql, param_types = nil) = ClientOps.prepare(self, name, sql, param_types)
     def stats = ClientOps.stats(self)
 
     def session(&block)
@@ -71,11 +73,31 @@ module PgPipeline
 
     def query(client, sql, params)
       ensure_started!(client)
-      sql = sql.to_s
-      SessionGuard.assert_multiplexable!(sql, mode: client.guard)
+      sql = RequestOps.snapshot_sql(sql)
+      SessionGuard.assert_multiplexable_normalized!(sql, mode: client.guard)
 
-      request = submit_with_failover(client, sql, params)
+      wait_for_request do
+        submit_with_failover(client) { Request.new(sql: sql, params: params) }
+      end
+    end
+
+    def prepare(client, name, sql, param_types)
+      ensure_started!(client)
+      sql = RequestOps.snapshot_sql(sql)
+      SessionGuard.assert_multiplexable_normalized!(sql, mode: client.guard)
+      pool(client).__send__(:prepare_statement, client, name, sql, param_types)
+    end
+
+    def query_prepared(client, statement, params)
+      ensure_started!(client)
+
+      wait_for_request do
+        submit_with_failover(client) { Request.prepared_query(statement, params: params) }
+      end
+    end
 
+    def wait_for_request
+      request = yield
       begin
         request.wait
       ensure
@@ -85,13 +107,13 @@ module PgPipeline
 
     # NotDispatchedError is safe to retry on a fresh Request by contract.
     # ShutdownError is retried only while the current Request is still pre-dispatch.
-    def submit_with_failover(client, sql, params)
+    def submit_with_failover(client)
       attempts = 0
       limit = [pool(client).pipeline_size, 1].max
       last_error = nil
 
       while attempts < limit
-        request = Request.new(sql: sql, params: params)
+        request = yield
         begin
           pool(client).__send__(:pipeline_driver).submit(request)
           return request

data/lib/pg_pipeline/connection_driver.rb

@@ -196,44 +196,46 @@ module PgPipeline
     end
 
     def owner_loop(d)
-      while d.running
-        event = d.events.dequeue
-
-        case event
-        when :requests
-          d.request_event_pending = false
-        when :submission_finished
-          nil
-        when :readable
-          begin
-            read_available(d)
-          ensure
-            d.reader_rearm.enqueue(:rearm) if d.running
-          end
-        when :writable
-          d.writer_armed = false
-          flush_output(d)
-        when :close
-          d.draining = true
-        when Array
-          tag, payload = event
-          if tag == :abort
-            fatal_close(d, payload)
-            break
-          end
-        end
-
-        drain_results(d)
-        pump_requests(d)
-        drain_results(d)
-        finish_graceful_close(d) if d.draining && drained?(d)
-      end
+      process_event(d, d.events.dequeue) while d.running
     rescue StandardError => e
       fatal_close(d, ConnectionLostError.new("driver crashed: #{e.class}: #{e.message}"))
     ensure
       fatal_close(d, ShutdownError.new("driver owner stopped before shutdown completed")) if d.running
     end
 
+    def process_event(d, event)
+      input_changed = false
+
+      case event
+      when :requests
+        d.request_event_pending = false
+      when :submission_finished
+        nil
+      when :readable
+        begin
+          read_available(d)
+          input_changed = true
+        ensure
+          d.reader_rearm.enqueue(:rearm) if d.running
+        end
+      when :writable
+        d.writer_armed = false
+        flush_output(d)
+      when :close
+        d.draining = true
+      when Array
+        tag, payload = event
+        if tag == :abort
+          fatal_close(d, payload)
+          return
+        end
+      end
+
+      drain_results(d) if input_changed
+      pump_requests(d) if d.running
+      finish_graceful_close(d) if d.running && d.draining && drained?(d)
+    end
+
     def notify_requests(d)
       return if d.request_event_pending
 
@@ -261,12 +263,12 @@ module PgPipeline
         dispatched = true
       end
 
-      flush_output(d) if dispatched || d.needs_flush
+      flush_output(d) if dispatched && !d.needs_flush
     end
 
     def send_unit(d, request)
       begin
-        d.conn.send_query_params(request.sql, request.params)
+        send_command(d.conn, request)
       rescue PG::UnableToSend => e
         d.dispatching = nil
         request.reject!(
@@ -281,9 +283,11 @@ module PgPipeline
           NotDispatchedError.new("query was rejected before libpq accepted it: #{e.class}: #{e.message}")
         )
         raise ConnectionLostError, "dispatch failed: #{e.class}: #{e.message}"
+      rescue ProtocolError
+        raise
       rescue StandardError => e
-        # ruby-pg prepares/encodes query parameters before calling PQsendQueryParams.
-        # A Ruby-side encoder/coercion exception therefore belongs only to this
+        # ruby-pg prepares/encodes query parameters before calling PQsend*. A
+        # Ruby-side encoder/coercion exception therefore belongs only to this
         # request and must not poison unrelated work already in the pipeline.
         request.reject!(e)
         return false
@@ -295,6 +299,23 @@ module PgPipeline
       raise ConnectionLostError, "dispatch Sync failed: #{e.class}: #{e.message}"
     end
 
+    def send_command(conn, request)
+      case request.operation
+      when :query
+        conn.send_query_params(request.sql, request.params)
+      when :prepare
+        if request.param_types.nil?
+          conn.send_prepare(request.statement_name, request.sql)
+        else
+          conn.send_prepare(request.statement_name, request.sql, request.param_types)
+        end
+      when :prepared_query
+        conn.send_query_prepared(request.statement_name, request.params)
+      else
+        raise ProtocolError, "unsupported request operation #{request.operation.inspect}"
+      end
+    end
+
     def reusable_after_send_rejection?(d)
       !d.conn.finished? &&
         d.conn.status == PG::CONNECTION_OK &&
@@ -325,7 +346,6 @@ module PgPipeline
 
     def read_available(d)
       d.conn.consume_input
-      drain_results(d)
     rescue PG::Error => e
       raise ConnectionLostError, "read failed: #{e.class}: #{e.message}"
     end

data/lib/pg_pipeline/pool.rb

@@ -7,6 +7,7 @@ require "async/notification"
 
 require_relative "errors"
 require_relative "connection_driver"
+require_relative "prepared_statement"
 require_relative "server_caps"
 
 module PgPipeline
@@ -58,6 +59,10 @@ module PgPipeline
       @supervisor = nil
       @task_parent = nil
 
+      @prepared_statements = {}
+      @prepared_generation = 0
+      @statement_sequence = 0
+
       @pinned_free = []
       @pinned_in_use = {}
       @pinned_gate = nil
@@ -107,6 +112,61 @@ module PgPipeline
       driver
     end
 
+    def prepare_statement(client, name, sql, param_types)
+      ensure_available!
+      logical_name = PreparedStatementOps.snapshot_name(name)
+      if @prepared_statements.key?(logical_name)
+        raise Error, "prepared statement #{logical_name.inspect} already exists"
+      end
+
+      @statement_sequence += 1
+      statement = PreparedStatement.new(
+        client: client,
+        name: logical_name,
+        physical_name: "pgp_#{@statement_sequence.to_s(36)}",
+        sql: sql,
+        param_types: param_types
+      )
+
+      @prepared_statements[logical_name] = statement
+      @prepared_generation += 1
+      requests = []
+
+      begin
+        drivers = @drivers.select(&:available?)
+        if drivers.empty?
+          raise NotDispatchedError, "no live pipeline connections; statement was not prepared"
+        end
+
+        requests = drivers.map do |driver|
+          Request.prepare(statement).tap { |request| driver.submit(request) }
+        end
+
+        first_error = nil
+        requests.each do |request|
+          begin
+            RequestOps.clear_result(request.wait)
+          rescue StandardError => e
+            if first_error
+              e.clear_result! if e.respond_to?(:clear_result!)
+            else
+              first_error = e
+            end
+          end
+        end
+        raise first_error if first_error
+
+        statement
+      rescue Exception
+        if @prepared_statements.delete(logical_name)
+          @prepared_generation += 1
+        end
+        raise
+      ensure
+        requests.each { |request| request.cancel! unless request.settled? }
+      end
+    end
+
     def with_pinned
       ensure_available!
       raise @pinned_error if @pinned_error
@@ -154,6 +214,7 @@ module PgPipeline
           free: @pinned_free.size,
           in_use: @pinned_in_use.size
         },
+        prepared_statements: (@prepared_statements || {}).size,
         reconnects: @reconnects,
         health_failures: @health_failures,
         supervisor_error: @supervisor_error&.message,
@@ -352,6 +413,7 @@ module PgPipeline
 
     def start_pipeline_driver(parent)
       conn = PoolOps.new_connection(@connection_args)
+      prepare_registered_statements(conn)
       driver = ConnectionDriver.new(conn, max_pending: @max_pending, max_in_flight: @max_in_flight)
       driver.start(parent: parent)
     rescue Exception
@@ -359,6 +421,29 @@ module PgPipeline
       raise
     end
 
+    def prepare_registered_statements(conn)
+      prepared = {}
+
+      loop do
+        generation = @prepared_generation || 0
+        statements = (@prepared_statements || {}).values.dup
+
+        statements.each do |statement|
+          next if prepared.key?(statement.physical_name)
+
+          result = if statement.param_types.nil?
+                     conn.prepare(statement.physical_name, statement.sql)
+                   else
+                     conn.prepare(statement.physical_name, statement.sql, statement.param_types)
+                   end
+          RequestOps.clear_result(result)
+          prepared[statement.physical_name] = true
+        end
+
+        break if generation == (@prepared_generation || 0)
+      end
+    end
+
     def release_pinned(owner, conn)
       begin
         if conn
@@ -473,32 +558,27 @@ module PgPipeline
     end
 
     def select_driver(drivers, rr)
-      min_load = nil
-      count = 0
-      drivers.each do |driver|
+      size = drivers.length
+      return [nil, rr] if size.zero?
+
+      best = nil
+      best_index = nil
+      best_load = nil
+
+      size.times do |offset|
+        index = (rr + offset) % size
+        driver = drivers[index]
         next unless driver.available?
 
         load = driver.load
-        if min_load.nil? || load < min_load
-          min_load = load
-          count = 1
-        elsif load == min_load
-          count += 1
+        if best.nil? || load < best_load
+          best = driver
+          best_index = index
+          best_load = load
         end
       end
-      return [nil, rr] if count.zero?
 
-      target = rr % count
-      index = 0
-      drivers.each do |driver|
-        next unless driver.available?
-        next unless driver.load == min_load
-
-        return [driver, rr + 1] if index == target
-
-        index += 1
-      end
-      [nil, rr]
+      best ? [best, (best_index + 1) % size] : [nil, rr]
     end
 
     def new_connection(connection_args)

data/lib/pg_pipeline/prepared_statement.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "request"
+
+module PgPipeline
+  class PreparedStatement
+    attr_reader :name, :sql, :param_types, :physical_name
+
+    def initialize(client:, name:, physical_name:, sql:, param_types: nil)
+      @client = client
+      @name = PreparedStatementOps.snapshot_name(name)
+      @physical_name = PreparedStatementOps.snapshot_name(physical_name)
+      @sql = RequestOps.snapshot_sql(sql)
+      @param_types = RequestOps.snapshot_param_types(param_types)
+      freeze
+    end
+
+    def query(params = []) = PreparedStatementOps.query(self, params)
+    alias call query
+
+    def inspect
+      "#<#{self.class} name=#{@name.inspect} sql=#{@sql.inspect}>"
+    end
+
+    private
+
+    attr_reader :client
+  end
+
+  module PreparedStatementOps
+    module_function
+
+    def query(statement, params)
+      ClientOps.query_prepared(statement.__send__(:client), statement, params)
+    end
+
+    def snapshot_name(name)
+      value = name.to_s
+      raise ArgumentError, "prepared statement name must not be empty" if value.empty?
+      raise ArgumentError, "prepared statement name must not contain NUL" if value.include?("\0")
+
+      value.frozen? ? value : value.dup.freeze
+    end
+
+  end
+end

data/lib/pg_pipeline/request.rb

@@ -11,7 +11,7 @@ module PgPipeline
                   :result, :error
 
     def initialize(sql:, params: nil)
-      @sql = sql.to_s.dup.freeze
+      @sql = RequestOps.snapshot_sql(sql)
       @params = RequestOps.snapshot_params(params)
       @state = :new
       @condition = Async::Notification.new
@@ -23,6 +23,14 @@ module PgPipeline
       @error = nil
     end
 
+    def self.prepare(statement) = PrepareRequest.new(statement)
+
+    def self.prepared_query(statement, params: nil)
+      PreparedQueryRequest.new(statement, params: params)
+    end
+
+    def operation = :query
+
     def queued! = RequestOps.transition!(self, :new, :queued)
     def dispatched! = RequestOps.transition!(self, :queued, :dispatched)
     def accept_result(result) = RequestOps.accept_result(self, result)
@@ -38,9 +46,37 @@ module PgPipeline
     def settled? = @settled
   end
 
+  class PrepareRequest < Request
+    attr_reader :statement_name, :param_types
+
+    def initialize(statement)
+      super(sql: statement.sql)
+      @statement_name = RequestOps.snapshot_name(statement.physical_name)
+      @param_types = RequestOps.snapshot_param_types(statement.param_types)
+    end
+
+    def operation = :prepare
+  end
+
+  class PreparedQueryRequest < Request
+    attr_reader :statement_name
+
+    def initialize(statement, params: nil)
+      super(sql: statement.sql, params: params)
+      @statement_name = RequestOps.snapshot_name(statement.physical_name)
+    end
+
+    def operation = :prepared_query
+  end
+
   module RequestOps
     module_function
 
+    def snapshot_sql(sql)
+      value = sql.to_s
+      value.frozen? ? value : value.dup.freeze
+    end
+
     def snapshot_params(params)
       values = params.nil? ? [] : params
       raise ArgumentError, "params must be an Array" unless values.is_a?(Array)
@@ -51,16 +87,32 @@ module PgPipeline
     def snapshot_value(value)
       case value
       when String
-        value.dup.freeze
+        value.frozen? ? value : value.dup.freeze
       when Hash
         value.each_with_object({}) do |(key, item), copy|
-          copy[key] = item.is_a?(String) ? item.dup.freeze : item
+          copy[key] = item.is_a?(String) && !item.frozen? ? item.dup.freeze : item
         end.freeze
       else
         value
       end
     end
 
+    def snapshot_name(name)
+      value = name.to_s
+      raise ArgumentError, "statement_name must not be empty" if value.empty?
+
+      value.frozen? ? value : value.dup.freeze
+    end
+
+    def snapshot_param_types(param_types)
+      return nil if param_types.nil?
+      raise ArgumentError, "param_types must be an Array or nil" unless param_types.is_a?(Array)
+
+      param_types.map { |oid| oid.nil? ? nil : Integer(oid) }.freeze
+    rescue ArgumentError, TypeError
+      raise ArgumentError, "param_types must contain only integer OIDs or nil"
+    end
+
     def transition!(req, from, to)
       unless req.state == from
         raise ProtocolError, "invalid request transition #{req.state.inspect} -> #{to.inspect}"

data/lib/pg_pipeline/session_guard.rb

@@ -30,7 +30,11 @@ module PgPipeline
     }.freeze
 
     def assert_multiplexable!(sql, mode: :default)
-      reason = unsafe_reason(sql, mode: mode)
+      assert_multiplexable_normalized!(sql, mode: normalize_mode!(mode))
+    end
+
+    def assert_multiplexable_normalized!(sql, mode:)
+      reason = unsafe_reason_normalized(sql, mode: mode)
       return true unless reason
 
       raise UnsafeMultiplexError,
@@ -43,9 +47,12 @@ module PgPipeline
     GUARD_CACHE_LIMIT = 2048
 
     def unsafe_reason(sql, mode: :default)
-      mode = normalize_mode!(mode)
+      unsafe_reason_normalized(sql, mode: normalize_mode!(mode))
+    end
+
+    def unsafe_reason_normalized(sql, mode:)
       key = sql.to_s
-      cache = guard_cache[mode]
+      cache = guard_cache.fetch(mode)
       return cache[key] if cache.key?(key)
 
       reason = compute_unsafe_reason(key, mode)

data/lib/pg_pipeline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgPipeline
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/lib/pg_pipeline.rb

@@ -7,6 +7,7 @@ require_relative "pg_pipeline/session_guard"
 require_relative "pg_pipeline/session"
 require_relative "pg_pipeline/transaction"
 require_relative "pg_pipeline/request"
+require_relative "pg_pipeline/prepared_statement"
 require_relative "pg_pipeline/connection_driver"
 require_relative "pg_pipeline/pool"
 require_relative "pg_pipeline/client"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_pipeline
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Roman Hajdarov
@@ -121,6 +121,7 @@ files:
 - lib/pg_pipeline/connection_driver.rb
 - lib/pg_pipeline/errors.rb
 - lib/pg_pipeline/pool.rb
+- lib/pg_pipeline/prepared_statement.rb
 - lib/pg_pipeline/request.rb
 - lib/pg_pipeline/server_caps.rb
 - lib/pg_pipeline/session.rb