pg_pipeline 0.3.1 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca8a6402d9ee49ae0393f519c135f4174248df64aa27332f0773e095eb3179c8
-  data.tar.gz: 3c01ed0c9be6950a3b4d264bc613e5fef94c56dc81cb8916c791902ffeac61b0
+  metadata.gz: f3bb4583fbf47130e8b86eec8f44c70577f053c9cacd1e9774a09a5b7a5d3999
+  data.tar.gz: '099f44877fde9db5faa63a776e31ecb6d1b56cc155dd08fd0b6dff52252a719e'
 SHA512:
-  metadata.gz: dc55189c229e3958e40781e30577ac82c3645f70fa55c2bce894baf9e0a423caa67d3ba533f77d5fce627943b424e0c7de2cea5f99a2ea25b0903022f438b3df
-  data.tar.gz: 508c35a99f8a9f5f3fa3665b741adaf58f593b6cc6c95fbfb86b48ded121adb010d4203fce6d9063274e510171e9f401ed0295b8691f2211ce273395cd7dcb9d
+  metadata.gz: ddc6fa628e441b5cf744a3521e0ca90a923cf732be59662c6cee9df5f522ad69319628d6ee98e18711baa28d8d42eef7585c0af6239cb9a8f4f921212338d014
+  data.tar.gz: 75e56315d776d60cadf07b675e048fdb674f06bc8b67fe960e95be4d7ed8bd89008eb25a8828eb96655994ed83fa23f392a541a73b77dbc4f113dc28261c815a

data/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Changelog
 
+## [0.3.3] - 2026-08-19
+
+Opt-in typed result decoding for multiplexed prepared statements. Default
+behaviour, Sync-per-unit, and the failure model are unchanged.
+
+### Added
+
+- `Client#prepare(..., typed: true)` — text format. The first `TUPLES_OK`
+  result builds a `TypeMapByColumn`; later dispatches reuse that map from the
+  `Request` (resolved at submit, never re-read from handle state at drain).
+  Column values arrive as typed Ruby objects (Integer, Time, BigDecimal, …)
+  instead of strings, for every PostgreSQL type ruby-pg covers in text mode.
+
+### Notes
+
+- This is an API feature, not a throughput lever. Typed columns that become
+  immediates (`int`, `bool`) drop one heap object each; the rest of the
+  per-query allocation is the control plane (`Request`, fibers, `PG::Result`).
+- `CoderMapsBundle` is built on a throwaway connection at the first
+  `prepare(..., typed: true)`, never at `Client.start` and never on a live
+  pipeline FIFO (a catalog query there desyncs Sync). Untyped `query` /
+  `prepare` do not touch type maps on the drain path.
+- A failed type-map apply is a request-local `QueryError`. `typed: true`
+  promised a typed value; the handle does not silently fall back to strings.
+- `bigdecimal` is an optional dependency of ruby-pg for `numeric` text
+  decoding (required as a gem on Ruby 3.4+). Without it, other typed columns
+  still work; `numeric` follows the registry.
+- Default path (no `typed:`): `TypeMapAllStrings`, text format, string keys.
+- Binary result format is not part of this release.
+
+## [0.3.2] - 2026-08-17
+
+Runtime correctness. Public SQL, Sync-per-unit, failure model, and the
+`Fiber::Scheduler` host contract are unchanged.
+
+### Fixed
+
+- Bounded waits (`Notification#wait`, `Task#wait`) park through
+  `scheduler.block(blocker, remaining)` and a monotonic deadline. They no
+  longer wrap `park` in `Timeout.timeout`. A wait timeout is not a work
+  timeout: `Notification#wait` no longer rescues `TimeoutError`, so an
+  enclosing `Runtime.with_timeout` cannot be swallowed by
+  `BoundedQueue#wait_on` or `wait_for_pinned_idle`. `wait(0)` polls.
+- `Runtime.with_timeout` (health probes and other work limits) calls
+  `scheduler.timeout_after(duration, Deadline, message)` when the hook
+  exists. `Deadline < Exception`, so `rescue => e` cannot eat it; the
+  method still raises `Runtime::TimeoutError` at its own boundary. A
+  scheduler without the hook falls back to stdlib `Timeout` and warns
+  once — `Thread#raise` can hit the wrong fiber.
+- `Notification#signal` and `Semaphore#release` skip a waiter that
+  `Task#stop` already released, or a fiber that is no longer alive. On a
+  deferred `unblock` the previous `shift` + wake handed the signal to the
+  stopped waiter and left the live one parked; a dead semaphore waiter
+  burned a pinned-pool slot. `park` also raises `Cancel` after a stop-wake
+  so the wait is not mistaken for a successful signal.
+
+### Unchanged
+
+- Per-fiber waiter-hash reuse, `Request` one-shot completion, watcher
+  `fiber_interrupt` / poll shutdown, and the host-installed scheduler
+  rule.
+
 ## [0.3.1] - 2026-08-09
 
 Reliability and correctness fixes on top of 0.3.0. No public API changes other

data/README.md

@@ -143,6 +143,27 @@ ensure
 end
 ```
 
+Pass `typed: true` to decode cells through ruby-pg's text type map (`Integer`,
+`Time`, `BigDecimal`, …) instead of strings. The map is built from the first
+result and reused. This does not change the wire format or the Sync-per-unit
+model; it is opt-in convenience, not a faster path.
+
+```ruby
+by_id = db.prepare(
+  "user_by_id",
+  "SELECT id, email FROM users WHERE id = $1",
+  [23],
+  typed: true
+)
+
+result = by_id.query([42])
+begin
+  result.first["id"] # => 42 (Integer)
+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

data/lib/pg_pipeline/client.rb

@@ -26,7 +26,9 @@ module PgPipeline
 
     def start = ClientOps.start(self)
     def query(sql, params = RequestOps::EMPTY_PARAMS) = ClientOps.query(self, sql, params)
-    def prepare(name, sql, param_types = nil) = ClientOps.prepare(self, name, sql, param_types)
+    def prepare(name, sql, param_types = nil, typed: false)
+      ClientOps.prepare(self, name, sql, param_types, typed: typed)
+    end
     def stats = ClientOps.stats(self)
 
     def session(&block)
@@ -78,18 +80,22 @@ module PgPipeline
       end
     end
 
-    def prepare(client, name, sql, param_types)
+    def prepare(client, name, sql, param_types, typed: false)
       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)
+      pool(client).__send__(:prepare_statement, client, name, sql, param_types, typed: typed)
     end
 
     def query_prepared(client, statement, params)
       ensure_started!(client)
 
       wait_for_request do
-        submit_with_failover(client) { Request.prepared_query(statement, params: params) }
+        submit_with_failover(client) do
+          request = Request.prepared_query(statement, params: params)
+          pool(client).bind_type_map(request, statement) if statement.typed?
+          request
+        end
       end
     end
 

data/lib/pg_pipeline/connection_driver.rb

@@ -13,7 +13,7 @@ module PgPipeline
     DEFAULT_MAX_PENDING = 256
     DEFAULT_MAX_IN_FLIGHT = 64
 
-    attr_reader :conn, :caps, :max_pending, :max_in_flight
+    attr_reader :conn, :caps, :max_pending, :max_in_flight, :type_maps
     attr_accessor :socket, :requests, :events, :reader_rearm, :writer_commands,
                   :inflight, :dispatching, :submitting, :accepting, :running,
                   :draining, :needs_flush, :writer_armed, :request_event_pending,
@@ -30,11 +30,13 @@ module PgPipeline
     def dispatches = @dispatches || 0
     def leaked_watchers = @leaked_watchers || 0
 
-    def initialize(conn, max_pending: DEFAULT_MAX_PENDING, max_in_flight: DEFAULT_MAX_IN_FLIGHT)
+    def initialize(conn, max_pending: DEFAULT_MAX_PENDING, max_in_flight: DEFAULT_MAX_IN_FLIGHT,
+                   type_maps: nil)
       @max_pending = DriverOps.positive_integer!(max_pending, :max_pending)
       @max_in_flight = DriverOps.positive_integer!(max_in_flight, :max_in_flight)
 
       @conn = conn
+      @type_maps = type_maps
       @caps = ServerCaps.from_connection(conn)
       @caps.assert_supported!
       DriverOps.warn_flush_coupling_once(@caps)
@@ -387,45 +389,61 @@ module PgPipeline
           request = d.inflight.first
           raise ProtocolError, "result without an in-flight request" unless request
 
-          if result.nil?
-            request.query_boundary!
-            next
-          end
-
-          status = result.result_status
-          case status
-          when PG::PGRES_TUPLES_OK
-            ensure_before_query_boundary!(request, status)
-            request.accept_result(result)
-          when PG::PGRES_PIPELINE_SYNC
-            clear_result(result)
-            complete_front(d, request)
-          when PG::PGRES_COMMAND_OK, PG::PGRES_EMPTY_QUERY
-            ensure_before_query_boundary!(request, status)
-            request.accept_result(result)
-          when PG::PGRES_FATAL_ERROR
-            ensure_before_query_boundary!(request, status)
-            request.record_error!(query_error(result), result: result)
-          when PG::PGRES_PIPELINE_ABORTED
-            ensure_before_query_boundary!(request, status)
-            clear_result(result)
-            request.record_error!(PipelineAbortedError.new("pipeline unit aborted"))
-          when PG::PGRES_BAD_RESPONSE
-            clear_result(result)
-            raise ProtocolError, "server response was not understood"
-          when PG::PGRES_COPY_IN, PG::PGRES_COPY_OUT, PG::PGRES_COPY_BOTH
-            clear_result(result)
-            raise ProtocolError, "COPY is not supported on the multiplexed pipeline"
-          else
-            clear_result(result)
-            raise ProtocolError, "unexpected pipeline result status #{status}"
-          end
+          handle_pipeline_result(d, request, result)
         end
       ensure
         d.results_read += read if read.positive?
       end
     end
 
+    def handle_pipeline_result(d, request, result)
+      if result.nil?
+        request.query_boundary!
+        return
+      end
+
+      status = result.result_status
+      case status
+      when PG::PGRES_TUPLES_OK
+        accept_tuples_ok(d, request, result)
+      when PG::PGRES_PIPELINE_SYNC
+        clear_result(result)
+        complete_front(d, request)
+      when PG::PGRES_COMMAND_OK, PG::PGRES_EMPTY_QUERY
+        ensure_before_query_boundary!(request, status)
+        request.accept_result(result)
+      when PG::PGRES_FATAL_ERROR
+        ensure_before_query_boundary!(request, status)
+        request.record_error!(query_error(result), result: result)
+      when PG::PGRES_PIPELINE_ABORTED
+        ensure_before_query_boundary!(request, status)
+        clear_result(result)
+        request.record_error!(PipelineAbortedError.new("pipeline unit aborted"))
+      when PG::PGRES_BAD_RESPONSE
+        reject_pipeline_status!(result, "server response was not understood")
+      when PG::PGRES_COPY_IN, PG::PGRES_COPY_OUT, PG::PGRES_COPY_BOTH
+        reject_pipeline_status!(result, "COPY is not supported on the multiplexed pipeline")
+      else
+        reject_pipeline_status!(result, "unexpected pipeline result status #{status}")
+      end
+    end
+
+    def accept_tuples_ok(d, request, result)
+      ensure_before_query_boundary!(request, PG::PGRES_TUPLES_OK)
+      begin
+        apply_type_map(d, request, result)
+        request.accept_result(result)
+      rescue StandardError => e
+        message = e.is_a?(Error) ? e.message : "typed result mapping failed: #{e.class}: #{e.message}"
+        request.record_error!(QueryError.new(message, cause_result: result), result: result)
+      end
+    end
+
+    def reject_pipeline_status!(result, message)
+      clear_result(result)
+      raise ProtocolError, message
+    end
+
     def ensure_before_query_boundary!(request, status)
       return unless request.query_boundary_seen?
 
@@ -644,6 +662,15 @@ module PgPipeline
       nil
     end
 
+    def apply_type_map(d, request, result)
+      return unless request.type_map
+
+      maps = d.type_maps
+      raise Error, "typed statement has no type-map registry" unless maps
+
+      maps.apply!(request, result, d.conn)
+    end
+
     def clear_result(result)
       result.clear if result.respond_to?(:clear)
     end

data/lib/pg_pipeline/pool.rb

@@ -6,6 +6,7 @@ require_relative "errors"
 require_relative "runtime"
 require_relative "connection_driver"
 require_relative "prepared_statement"
+require_relative "type_maps"
 require_relative "server_caps"
 
 module PgPipeline
@@ -64,6 +65,7 @@ module PgPipeline
       @prepared_statements = {}
       @prepared_generation = 0
       @statement_sequence = 0
+      @type_maps = TypeMaps.new
 
       @pinned_free = []
       @pinned_in_use = {}
@@ -113,59 +115,90 @@ module PgPipeline
       driver
     end
 
-    def prepare_statement(client, name, sql, param_types)
+    def bind_type_map(request, statement)
+      return unless statement.typed?
+
+      maps = @type_maps
+      return unless maps
+
+      maps.bind(request, statement)
+    end
+
+    def prepare_statement(client, name, sql, param_types, typed: false)
       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 = register_prepared_statement(client, logical_name, sql, param_types, typed)
+      requests = []
+
+      begin
+        requests = dispatch_prepare(statement)
+        await_prepares!(requests)
+        statement
+      rescue Exception
+        drop_prepared_statement(logical_name, statement)
+        raise
+      ensure
+        requests.each { |request| request.cancel! unless request.settled? }
+      end
+    end
+
+    def register_prepared_statement(client, logical_name, sql, param_types, typed)
       @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
+        param_types: param_types,
+        typed: typed
       )
 
       @prepared_statements[logical_name] = statement
+      register_typed_maps(statement) if statement.typed?
       @prepared_generation += 1
-      requests = []
+      statement
+    end
 
-      begin
-        drivers = @drivers.select(&:available?)
-        if drivers.empty?
-          raise NotDispatchedError, "no live pipeline connections; statement was not prepared"
-        end
+    def register_typed_maps(statement)
+      @type_maps ||= TypeMaps.new
+      @type_maps.register(statement)
+      @type_maps.ensure_bundle!(@connection_args)
+    end
 
-        requests = drivers.map do |driver|
-          Request.prepare(statement).tap { |request| driver.submit(request) }
-        end
+    def dispatch_prepare(statement)
+      drivers = @drivers.select(&:available?)
+      if drivers.empty?
+        raise NotDispatchedError, "no live pipeline connections; statement was not prepared"
+      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
+      drivers.map { |driver| Request.prepare(statement).tap { |r| driver.submit(r) } }
+    end
 
-        statement
-      rescue Exception
-        if @prepared_statements.delete(logical_name)
-          @prepared_generation += 1
+    def await_prepares!(requests)
+      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
-        raise
-      ensure
-        requests.each { |request| request.cancel! unless request.settled? }
       end
+      raise first_error if first_error
+    end
+
+    def drop_prepared_statement(logical_name, statement)
+      return unless @prepared_statements.delete(logical_name)
+
+      @type_maps.unregister(statement.physical_name) if statement&.typed? && @type_maps
+      @prepared_generation += 1
     end
 
     def with_pinned
@@ -174,31 +207,11 @@ module PgPipeline
       raise Error, "pinned pool is disabled (pinned_size=0)" if @pinned_size.zero?
 
       owner = Fiber.current
-      if @pinned_owners[owner].positive?
-        raise RecursiveCheckoutError,
-              "nested Client#session/transaction on the same fiber is not allowed; " \
-              "use Transaction#savepoint for nested atomicity"
-      end
+      assert_not_nested_pinned!(owner)
 
       @pinned_gate.acquire do
-        raise @pinned_error if @pinned_error
-        raise ShutdownError, "pool is closing" if @closing
-
-        conn = nil
-        @pinned_active += 1
-        @pinned_owners[owner] += 1
-
-        begin
-          conn = @pinned_free.pop || PoolOps.new_connection(@connection_args)
-          raise @pinned_error if @pinned_error
-          raise ShutdownError, "pool is closing" if @closing
-
-          @pinned_in_use[conn] = owner
-          yield conn
-        ensure
-          @pinned_in_use.delete(conn) if conn
-          release_pinned(owner, conn)
-        end
+        assert_pinned_open!
+        run_pinned(owner) { |conn| yield conn }
       end
     end
 
@@ -453,7 +466,7 @@ module PgPipeline
     def start_pipeline_driver
       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 = ConnectionDriver.new(conn, max_pending: @max_pending, max_in_flight: @max_in_flight, type_maps: @type_maps)
       driver.start
     rescue Exception
       PoolOps.safe_close(conn) if conn
@@ -471,10 +484,11 @@ module PgPipeline
           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
+            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
@@ -483,22 +497,41 @@ module PgPipeline
       end
     end
 
-    def release_pinned(owner, conn)
-      if conn
-        if @closing
-          PoolOps.safe_close(conn)
-        else
-          recycled = recycle_pinned_connection(conn)
-
-          if recycled
-            if @closing
-              PoolOps.safe_close(recycled)
-            else
-              @pinned_free << recycled
-            end
-          end
-        end
+    def assert_not_nested_pinned!(owner)
+      return unless @pinned_owners[owner].positive?
+
+      raise RecursiveCheckoutError,
+            "nested Client#session/transaction on the same fiber is not allowed; " \
+            "use Transaction#savepoint for nested atomicity"
+    end
+
+    def assert_pinned_open!
+      raise @pinned_error if @pinned_error
+      raise ShutdownError, "pool is closing" if @closing
+    end
+
+    def run_pinned(owner)
+      conn = nil
+      @pinned_active += 1
+      @pinned_owners[owner] += 1
+
+      begin
+        conn = take_pinned_connection
+        assert_pinned_open!
+        @pinned_in_use[conn] = owner
+        yield conn
+      ensure
+        @pinned_in_use.delete(conn) if conn
+        release_pinned(owner, conn)
       end
+    end
+
+    def take_pinned_connection
+      @pinned_free.pop || PoolOps.new_connection(@connection_args)
+    end
+
+    def release_pinned(owner, conn)
+      return_pinned_connection(conn) if conn
     ensure
       @pinned_active -= 1
       @pinned_owners[owner] -= 1
@@ -506,6 +539,22 @@ module PgPipeline
       @pinned_idle.signal if @pinned_active.zero?
     end
 
+    def return_pinned_connection(conn)
+      if @closing
+        PoolOps.safe_close(conn)
+        return
+      end
+
+      recycled = recycle_pinned_connection(conn)
+      return unless recycled
+
+      if @closing
+        PoolOps.safe_close(recycled)
+      else
+        @pinned_free << recycled
+      end
+    end
+
     def recycle_pinned_connection(conn)
       if conn.server_version < DISCARD_SEQUENCES_SERVER_VERSION
         PoolOps.safe_close(conn)
@@ -602,9 +651,7 @@ module PgPipeline
 
       start = rr % size
       best = nil
-      best_index = 0
-      best_load = 0
-      offset = 0
+      best_index, best_load, offset = 0, 0, 0
 
       while offset < size
         index = start + offset

data/lib/pg_pipeline/prepared_statement.rb

@@ -5,22 +5,26 @@ require_relative "request"
 
 module PgPipeline
   class PreparedStatement
-    attr_reader :name, :sql, :param_types, :physical_name
+    attr_reader :name, :sql, :param_types, :physical_name, :typed
 
-    def initialize(client:, name:, physical_name:, sql:, param_types: nil)
+    def initialize(client:, name:, physical_name:, sql:, param_types: nil, typed: false)
       @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)
+      @typed = !!typed
       freeze
     end
 
+    def typed? = @typed
+
     def query(params = RequestOps::EMPTY_PARAMS) = PreparedStatementOps.query(self, params)
     alias call query
 
     def inspect
-      "#<#{self.class} name=#{@name.inspect} sql=#{@sql.inspect}>"
+      flag = @typed ? " typed" : ""
+      "#<#{self.class} name=#{@name.inspect} sql=#{@sql.inspect}#{flag}>"
     end
 
     private
@@ -42,6 +46,5 @@ module PgPipeline
 
       value.frozen? ? value : value.dup.freeze
     end
-
   end
 end

data/lib/pg_pipeline/request.rb

@@ -6,7 +6,7 @@ module PgPipeline
   class Request
     attr_reader :sql, :params
     attr_accessor :state, :cancelled, :settled, :result_seen, :query_boundary_seen,
-                  :result, :error, :waiter, :waiter_scheduler
+                  :result, :error, :waiter, :waiter_scheduler, :type_map
 
     def initialize(sql:, params: nil)
       @sql = RequestOps.snapshot_sql(sql)
@@ -20,6 +20,7 @@ module PgPipeline
       @error = nil
       @waiter = nil
       @waiter_scheduler = nil
+      @type_map = nil
     end
 
     def self.build(sql, params)
@@ -64,6 +65,7 @@ module PgPipeline
       @error = nil
       @waiter = nil
       @waiter_scheduler = nil
+      @type_map = nil
       self
     end
   end

data/lib/pg_pipeline/runtime/notification.rb

@@ -7,19 +7,24 @@ module PgPipeline
         @waiters = []
       end
 
+      def waiting = @waiters.size
+
       def wait(timeout = nil)
+        wait_until(Runtime.deadline_for(timeout))
+      end
+
+      def wait_until(deadline = nil)
         Runtime.with_waiter(self, @waiters) do |waiter|
-          Runtime.with_timeout(timeout) { Runtime.park(self, waiter) { false } }
-          true
-        rescue TimeoutError
-          false
+          Runtime.park(self, waiter, deadline) { false }
         end
       end
 
       def signal
-        waiter = @waiters.shift or return false
-        Runtime.wake_dequeued(waiter, self)
-        true
+        while (waiter = @waiters.shift)
+          return true if Runtime.wake_dequeued(waiter, self)
+        end
+
+        false
       end
 
       def signal_all

data/lib/pg_pipeline/runtime/semaphore.rb

@@ -23,12 +23,12 @@ module PgPipeline
       end
 
       def release
-        if (node = @waiting.shift)
+        while (node = @waiting.shift)
           node.grant!
-          node.resume
-        else
-          @available += 1
+          return @available if node.resume
         end
+
+        @available += 1
         @available
       end
 
@@ -126,9 +126,10 @@ module PgPipeline
 
         def resume
           fiber = @fiber
-          return unless fiber.alive?
+          return false unless fiber.alive?
 
           @scheduler.unblock(@blocker, fiber)
+          true
         end
       end
 

data/lib/pg_pipeline/runtime/task.rb

@@ -22,7 +22,10 @@ module PgPipeline
       end
 
       def wait(timeout = nil)
-        Runtime.with_timeout(timeout) { join }
+        unless @done
+          deadline = Runtime.deadline_for(timeout)
+          raise TimeoutError, "task did not finish in time" unless join(deadline)
+        end
         raise @error if @error
 
         @result
@@ -94,8 +97,8 @@ module PgPipeline
 
       def release_blocker
         waiter = @blocker or return false
-        Runtime.wake(waiter, waiter[:blocker])
-        waiter[:fiber].alive?
+
+        Runtime.wake(waiter, waiter[:blocker]) && waiter[:fiber].alive?
       end
 
       def complete(result, error)
@@ -107,11 +110,11 @@ module PgPipeline
         wake_waiters
       end
 
-      def join
-        return if @done
+      def join(deadline)
+        return true if @done
 
         Runtime.with_waiter(self, @waiters) do |waiter|
-          Runtime.park(self, waiter) { @done }
+          Runtime.park(self, waiter, deadline) { @done }
         end
       end
 

data/lib/pg_pipeline/runtime.rb

@@ -7,12 +7,25 @@ require_relative "errors"
 module PgPipeline
   module Runtime
     class Cancel < Exception; end
+    class Deadline < Exception; end
     class TimeoutError < Error; end
 
     module_function
 
     CURRENT_TASK_KEY = :pg_pipeline_current_task
     WAITER_KEY = :pg_pipeline_waiter
+    DEADLINE_MESSAGE = "execution expired"
+
+    MISSING_TIMEOUT_HOOK_WARNING = <<~MESSAGE
+      pg_pipeline: %s does not implement #timeout_after.
+
+      Falling back to stdlib Timeout, which uses Thread#raise and can deliver
+      the timeout to an unrelated fiber. Use a scheduler that implements
+      #timeout_after (async, itsi-scheduler) or avoid Runtime.with_timeout
+      on this host.
+    MESSAGE
+
+    @warned_schedulers = {}
 
     def spawn(name: nil, &block)
       Task.spawn(name: name, &block)
@@ -22,6 +35,10 @@ module PgPipeline
       Fiber.scheduler or raise Error, "operation requires an active Fiber scheduler"
     end
 
+    def native_timeouts?(target = Fiber.scheduler)
+      !target.nil? && target.respond_to?(:timeout_after)
+    end
+
     def current_task
       Thread.current[CURRENT_TASK_KEY]
     end
@@ -44,16 +61,20 @@ module PgPipeline
       waiter
     end
 
-    def park(blocker, waiter)
+    def park(blocker, waiter, deadline = nil)
       scheduler = waiter[:scheduler]
       task = current_task
       task&.enter_block(waiter)
 
       until waiter[:ready] || yield
-        scheduler.block(blocker, nil)
+        remaining = deadline ? (deadline - monotonic_now) : nil
+        return false if deadline && remaining <= 0
+
+        scheduler.block(blocker, remaining)
         task&.raise_if_cancelled!
       end
-      nil
+      task&.raise_if_cancelled!
+      true
     ensure
       waiter[:blocker] = nil
       task&.exit_block
@@ -65,7 +86,10 @@ module PgPipeline
       waiters << waiter
       yield waiter
     ensure
-      waiters.delete(waiter) if waiter[:queued]
+      if waiter[:queued]
+        waiters.delete(waiter)
+        waiter[:queued] = false
+      end
     end
 
     def wake_dequeued(waiter, blocker)
@@ -73,21 +97,59 @@ module PgPipeline
       wake(waiter, blocker)
     end
 
+    def wake(waiter, blocker)
+      return false if waiter[:ready]
+
+      waiter[:ready] = true
+      fiber = waiter[:fiber]
+      return false unless fiber.alive?
+
+      waiter[:scheduler].unblock(blocker, fiber)
+      true
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def deadline_for(timeout)
+      return nil if timeout.nil?
+
+      seconds = Float(timeout)
+      raise ArgumentError, "timeout must be non-negative and finite" unless seconds.finite? && seconds >= 0
+
+      monotonic_now + seconds
+    end
+
     def with_timeout(duration)
       return yield if duration.nil?
 
-      timeout = Float(duration)
-      raise ArgumentError, "timeout must be non-negative and finite" unless timeout.finite? && timeout >= 0
+      seconds = Float(duration)
+      raise ArgumentError, "timeout must be non-negative and finite" unless seconds.finite? && seconds >= 0
 
-      ::Timeout.timeout(timeout, TimeoutError) { yield }
+      begin
+        arm_deadline(seconds) { yield }
+      rescue Deadline => e
+        raise TimeoutError, e.message
+      end
     end
 
-    def wake(waiter, blocker)
-      waiter[:ready] = true
-      fiber = waiter[:fiber]
-      return unless fiber.alive?
+    def arm_deadline(seconds, &block)
+      target = Fiber.scheduler
+      if native_timeouts?(target)
+        return target.timeout_after(seconds, Deadline, DEADLINE_MESSAGE, &block)
+      end
 
-      waiter[:scheduler].unblock(blocker, fiber)
+      warn_missing_timeout_hook(target) if target
+      ::Timeout.timeout(seconds, Deadline, DEADLINE_MESSAGE, &block)
+    end
+
+    def warn_missing_timeout_hook(target)
+      key = target.class
+      return if @warned_schedulers[key]
+
+      @warned_schedulers[key] = true
+      warn(format(MISSING_TIMEOUT_HOOK_WARNING, key))
     end
   end
 end

data/lib/pg_pipeline/type_maps.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "pg"
+require_relative "errors"
+
+module PgPipeline
+  class TypeMaps
+    PENDING = Object.new.freeze
+
+    def initialize
+      @cache = {}
+      @wants_typed = {}
+      @bundle = nil
+      @text_map_for_results = nil
+    end
+
+    def register(statement)
+      @wants_typed[statement.physical_name] = true if statement.typed?
+    end
+
+    def unregister(physical_name)
+      @cache.delete(physical_name)
+      @wants_typed.delete(physical_name)
+    end
+
+    def typed?(physical_name)
+      @wants_typed[physical_name]
+    end
+
+    def cached(physical_name)
+      @cache[physical_name]
+    end
+
+    def bind(request, statement)
+      return unless statement.typed?
+
+      request.type_map = @cache[statement.physical_name] || PENDING
+    end
+
+    def ensure_bundle!(connection_args)
+      return if @bundle && @bundle != :failed
+
+      conn = nil
+      conn = connection_args.nil? ? PG::Connection.new : PG::Connection.new(connection_args)
+      @bundle = PG::BasicTypeRegistry::CoderMapsBundle.new(conn)
+      @text_map_for_results = PG::BasicTypeMapForResults.new(@bundle)
+    rescue StandardError => e
+      @bundle = :failed
+      @text_map_for_results = nil
+      raise Error, "failed to build CoderMapsBundle (#{e.class}: #{e.message})"
+    ensure
+      begin
+        conn&.close
+      rescue StandardError
+        nil
+      end
+    end
+
+    def apply!(request, result, _conn)
+      map = request.type_map
+      return if map.nil?
+
+      if map.equal?(PENDING)
+        name = request.statement_name
+        map = @cache[name]
+        unless map
+          map = build_column_map!(result)
+          @cache[name] = map
+        end
+        request.type_map = map
+      end
+
+      result.type_map = map
+    end
+
+    private
+
+    def build_column_map!(result)
+      unless result.result_status == PG::PGRES_TUPLES_OK && result.nfields.positive?
+        raise Error, "typed mapping requires a TUPLES_OK result with at least one column"
+      end
+      if @bundle == :failed || @text_map_for_results.nil?
+        raise Error, "typed result mapping is unavailable (CoderMapsBundle failed)"
+      end
+
+      @text_map_for_results.build_column_map(result)
+    end
+  end
+end

data/lib/pg_pipeline/version.rb

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

data/lib/pg_pipeline.rb

@@ -9,6 +9,7 @@ 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/type_maps"
 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.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Roman Hajdarov
@@ -134,6 +134,7 @@ files:
 - lib/pg_pipeline/session.rb
 - lib/pg_pipeline/session_guard.rb
 - lib/pg_pipeline/transaction.rb
+- lib/pg_pipeline/type_maps.rb
 - lib/pg_pipeline/version.rb
 homepage: https://github.com/roman-haidarov/pg_pipeline
 licenses: