pg_pipeline 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7fdda2e5d806be070a3255e8cef4a63b72acaeac87d7a7777d580bfb0fc0d0a
-  data.tar.gz: 2b23bf8808241eb64396672959a86ae86c26af05bb0d72049de646907cc9e99d
+  metadata.gz: f3bb4583fbf47130e8b86eec8f44c70577f053c9cacd1e9774a09a5b7a5d3999
+  data.tar.gz: '099f44877fde9db5faa63a776e31ecb6d1b56cc155dd08fd0b6dff52252a719e'
 SHA512:
-  metadata.gz: 37a5b065506fb61a675a72023057b0d24254ea7fa411ea358c68e255e0ffabf53079ab3a7214be59b2d09b02063aa2c09875576868a213df8c91526f90834ebd
-  data.tar.gz: fb0e3b15f73e8de66b56d09c7791b8e357477c859b83293474ec48c15d41d12298f91c974bd8ebeb0ae2cc6a3437ed598c442e6eb26e8a13787e71a3d35856f7
+  metadata.gz: ddc6fa628e441b5cf744a3521e0ca90a923cf732be59662c6cee9df5f522ad69319628d6ee98e18711baa28d8d42eef7585c0af6239cb9a8f4f921212338d014
+  data.tar.gz: 75e56315d776d60cadf07b675e048fdb674f06bc8b67fe960e95be4d7ed8bd89008eb25a8828eb96655994ed83fa23f392a541a73b77dbc4f113dc28261c815a

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # 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

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/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.2"
+  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.2
+  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: