pg_pipeline 0.3.2 → 0.3.4

data/lib/pg_pipeline/prepared_statement.rb

@@ -1,26 +1,30 @@
 # frozen_string_literal: true
 
-require_relative "errors"
-require_relative "request"
+require_relative 'errors'
+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
@@ -37,11 +41,10 @@ module PgPipeline
 
     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")
+      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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "errors"
+require_relative 'errors'
 
 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
@@ -117,7 +119,7 @@ module PgPipeline
 
     def snapshot_params(params)
       return EMPTY_PARAMS if params.nil?
-      raise ArgumentError, "params must be an Array" unless params.is_a?(Array)
+      raise ArgumentError, 'params must be an Array' unless params.is_a?(Array)
       return EMPTY_PARAMS if params.empty?
 
       return params if params.frozen? && immutable_values?(params)
@@ -158,24 +160,23 @@ module PgPipeline
 
     def snapshot_name(name)
       value = name.to_s
-      raise ArgumentError, "statement_name must not be empty" if value.empty?
+      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)
+      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"
+      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}"
-      end
+      state = req.state
+      raise ProtocolError, "invalid request transition #{state.inspect} -> #{to.inspect}" unless state == from
 
       req.state = to
     end
@@ -203,14 +204,14 @@ module PgPipeline
     end
 
     def query_boundary!(req)
-      raise ProtocolError, "query boundary before query result" unless req.result_seen
-      raise ProtocolError, "duplicate query boundary" if req.query_boundary_seen
+      raise ProtocolError, 'query boundary before query result' unless req.result_seen
+      raise ProtocolError, 'duplicate query boundary' if req.query_boundary_seen
 
       req.query_boundary_seen = true
     end
 
     def finish!(req)
-      raise ProtocolError, "sync arrived before query boundary" unless req.query_boundary_seen
+      raise ProtocolError, 'sync arrived before query boundary' unless req.query_boundary_seen
       return if req.settled
 
       req.settled = true
@@ -235,21 +236,23 @@ module PgPipeline
       req.cancelled = true
       clear_result(req.result)
       req.result = nil
-      req.error.clear_result! if req.error.respond_to?(:clear_result!)
+      error = req.error
+      error.clear_result! if error.respond_to?(:clear_result!)
     end
 
     def wait(req)
       park_waiter(req) unless req.settled
-      raise req.error if req.error
+      error = req.error
+      raise error if error
 
       req.result
     end
 
     def park_waiter(req)
-      raise ProtocolError, "request already has a waiter" if req.waiter
+      raise ProtocolError, 'request already has a waiter' if req.waiter
 
       scheduler = Fiber.scheduler
-      raise Error, "request wait requires an active Fiber scheduler" unless scheduler
+      raise Error, 'request wait requires an active Fiber scheduler' unless scheduler
 
       waiter = Fiber.current
       req.waiter = waiter
@@ -274,8 +277,8 @@ module PgPipeline
     end
 
     def assert_result_slot!(req)
-      raise ProtocolError, "result arrived after query boundary" if req.query_boundary_seen
-      raise ProtocolError, "multiple results for one pipeline unit" if req.result_seen
+      raise ProtocolError, 'result arrived after query boundary' if req.query_boundary_seen
+      raise ProtocolError, 'multiple results for one pipeline unit' if req.result_seen
     end
 
     def clear_result(result)

data/lib/pg_pipeline/runtime/notification.rb

@@ -28,7 +28,8 @@ module PgPipeline
       end
 
       def signal_all
-        pending, @waiters = @waiters, []
+        pending = @waiters
+        @waiters = []
         pending.each { |waiter| Runtime.wake_dequeued(waiter, self) }
         nil
       end

data/lib/pg_pipeline/runtime/semaphore.rb

@@ -5,7 +5,7 @@ module PgPipeline
     class Semaphore
       def initialize(limit)
         @limit = Integer(limit)
-        raise ArgumentError, "limit must be >= 0" if @limit.negative?
+        raise ArgumentError, 'limit must be >= 0' if @limit.negative?
 
         @available = @limit
         @waiting = WaitList.new
@@ -71,7 +71,7 @@ module PgPipeline
         def empty? = @head.nil?
 
         def push(node)
-          raise ArgumentError, "node already queued" if node.list
+          raise ArgumentError, 'node already queued' if node.list
 
           node.list = self
           node.prev = @tail
@@ -108,7 +108,7 @@ module PgPipeline
           @list = @prev = @next = nil
           @granted = false
           @scheduler = Fiber.scheduler
-          @waiter = {fiber: fiber, scheduler: @scheduler, ready: false, blocker: blocker, queued: true}
+          @waiter = { fiber: fiber, scheduler: @scheduler, ready: false, blocker: blocker, queued: true }
         end
 
         def granted? = @granted

data/lib/pg_pipeline/runtime/task.rb

@@ -6,7 +6,7 @@ module PgPipeline
       attr_reader :fiber, :name, :error
 
       def self.spawn(name: nil, &block)
-        raise ArgumentError, "block required" unless block
+        raise ArgumentError, 'block required' unless block
 
         task = new(name: name)
         task.__send__(:start, &block)
@@ -14,8 +14,13 @@ module PgPipeline
       end
 
       def initialize(name: nil)
-        @fiber, @scheduler, @blocker, @result, @error = nil, nil, nil, nil, nil
-        @done, @cancelled = false, false
+        @fiber = nil
+        @scheduler = nil
+        @blocker = nil
+        @result = nil
+        @error = nil
+        @done = false
+        @cancelled = false
 
         @name = name
         @waiters = []
@@ -24,7 +29,7 @@ module PgPipeline
       def wait(timeout = nil)
         unless @done
           deadline = Runtime.deadline_for(timeout)
-          raise TimeoutError, "task did not finish in time" unless join(deadline)
+          raise TimeoutError, 'task did not finish in time' unless join(deadline)
         end
         raise @error if @error
 
@@ -45,7 +50,7 @@ module PgPipeline
       def cancelled? = @cancelled
 
       def raise_if_cancelled!
-        raise Cancel, "task stopped" if @cancelled
+        raise Cancel, 'task stopped' if @cancelled
       end
 
       def enter_block(waiter)
@@ -68,7 +73,7 @@ module PgPipeline
           this.__send__(:adopt_fiber, Fiber.current)
           Thread.current[Runtime::CURRENT_TASK_KEY] = this
           begin
-            this.__send__(:complete, block.call, nil)
+            this.__send__(:complete, yield, nil)
           rescue Cancel
             this.__send__(:complete, nil, nil)
           rescue Exception => e
@@ -89,7 +94,7 @@ module PgPipeline
         return false unless fiber&.alive?
         return false unless scheduler&.respond_to?(:fiber_interrupt)
 
-        result = scheduler.fiber_interrupt(fiber, Cancel.new("task stopped"))
+        result = scheduler.fiber_interrupt(fiber, Cancel.new('task stopped'))
         result != false
       rescue FiberError
         false
@@ -119,7 +124,8 @@ module PgPipeline
       end
 
       def wake_waiters
-        pending, @waiters = @waiters, []
+        pending = @waiters
+        @waiters = []
         pending.each { |waiter| Runtime.wake_dequeued(waiter, self) }
       end
     end

data/lib/pg_pipeline/runtime.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "timeout"
+require 'timeout'
 
-require_relative "errors"
+require_relative 'errors'
 
 module PgPipeline
   module Runtime
@@ -14,7 +14,7 @@ module PgPipeline
 
     CURRENT_TASK_KEY = :pg_pipeline_current_task
     WAITER_KEY = :pg_pipeline_waiter
-    DEADLINE_MESSAGE = "execution expired"
+    DEADLINE_MESSAGE = 'execution expired'
 
     MISSING_TIMEOUT_HOOK_WARNING = <<~MESSAGE
       pg_pipeline: %s does not implement #timeout_after.
@@ -32,7 +32,7 @@ module PgPipeline
     end
 
     def scheduler!
-      Fiber.scheduler or raise Error, "operation requires an active Fiber scheduler"
+      Fiber.scheduler or raise Error, 'operation requires an active Fiber scheduler'
     end
 
     def native_timeouts?(target = Fiber.scheduler)
@@ -48,9 +48,10 @@ module PgPipeline
         fiber: nil, scheduler: nil, ready: false, blocker: nil
       }
 
-      if waiter[:blocker]
-        raise Error, "waiter already parked on #{waiter[:blocker].class}; " \
-                     "a fiber may only park in one place at a time"
+      current_blocker = waiter[:blocker]
+      if current_blocker
+        raise Error, "waiter already parked on #{current_blocker.class}; " \
+                     'a fiber may only park in one place at a time'
       end
 
       waiter[:fiber] = Fiber.current
@@ -116,19 +117,19 @@ module PgPipeline
       return nil if timeout.nil?
 
       seconds = Float(timeout)
-      raise ArgumentError, "timeout must be non-negative and finite" unless seconds.finite? && seconds >= 0
+      raise ArgumentError, 'timeout must be non-negative and finite' unless seconds.finite? && seconds >= 0
 
       monotonic_now + seconds
     end
 
-    def with_timeout(duration)
+    def with_timeout(duration, &block)
       return yield if duration.nil?
 
       seconds = Float(duration)
-      raise ArgumentError, "timeout must be non-negative and finite" unless seconds.finite? && seconds >= 0
+      raise ArgumentError, 'timeout must be non-negative and finite' unless seconds.finite? && seconds >= 0
 
       begin
-        arm_deadline(seconds) { yield }
+        arm_deadline(seconds, &block)
       rescue Deadline => e
         raise TimeoutError, e.message
       end
@@ -136,9 +137,7 @@ module PgPipeline
 
     def arm_deadline(seconds, &block)
       target = Fiber.scheduler
-      if native_timeouts?(target)
-        return target.timeout_after(seconds, Deadline, DEADLINE_MESSAGE, &block)
-      end
+      return target.timeout_after(seconds, Deadline, DEADLINE_MESSAGE, &block) if native_timeouts?(target)
 
       warn_missing_timeout_hook(target) if target
       ::Timeout.timeout(seconds, Deadline, DEADLINE_MESSAGE, &block)
@@ -154,7 +153,7 @@ module PgPipeline
   end
 end
 
-require_relative "runtime/notification"
-require_relative "runtime/queue"
-require_relative "runtime/semaphore"
-require_relative "runtime/task"
+require_relative 'runtime/notification'
+require_relative 'runtime/queue'
+require_relative 'runtime/semaphore'
+require_relative 'runtime/task'

data/lib/pg_pipeline/server_caps.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "pg"
+require 'pg'
 
-require_relative "errors"
+require_relative 'errors'
 
 module PgPipeline
   class ServerCaps
@@ -59,7 +59,7 @@ module PgPipeline
       return true if supported?(caps)
 
       raise UnsupportedServerError,
-            "pg_pipeline requires libpq >= 14, PostgreSQL protocol v3, and " \
+            'pg_pipeline requires libpq >= 14, PostgreSQL protocol v3, and ' \
             "ruby-pg pipeline bindings; libpq=#{caps.libpq_version}, " \
             "protocol=#{caps.protocol_version}, pipeline_api=#{caps.pipeline_api}"
     end

data/lib/pg_pipeline/session.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "errors"
+require_relative 'errors'
 
 module PgPipeline
   class Session
@@ -30,10 +30,10 @@ module PgPipeline
 
     def ensure_active!(session)
       conn = connection(session)
-      raise Error, "session handle is no longer active" unless session.active? && conn
+      raise Error, 'session handle is no longer active' unless session.active? && conn
       return if Fiber.current.equal?(session.owner_fiber)
 
-      raise Error, "session handle is fiber-local and cannot be used from another fiber"
+      raise Error, 'session handle is fiber-local and cannot be used from another fiber'
     end
 
     def query(session, sql, params)
@@ -43,19 +43,21 @@ module PgPipeline
 
     def exec(session, sql, params = nil)
       ensure_active!(session)
+      conn = connection(session)
       if params.nil?
-        connection(session).exec(sql)
+        conn.exec(sql)
       else
-        connection(session).exec_params(sql, params)
+        conn.exec_params(sql, params)
       end
     end
 
     def prepare(session, name, sql, param_types)
       ensure_active!(session)
+      conn = connection(session)
       if param_types
-        connection(session).prepare(name, sql, param_types)
+        conn.prepare(name, sql, param_types)
       else
-        connection(session).prepare(name, sql)
+        conn.prepare(name, sql)
       end
     end