pg_pipeline 0.3.3 → 0.3.4

data/lib/pg_pipeline/transaction.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "pg"
+require 'pg'
 
-require_relative "session"
+require_relative 'session'
 
 module PgPipeline
   class Transaction < Session
@@ -30,68 +30,67 @@ module PgPipeline
   module TransactionOps
     module_function
 
-    def run(tx)
-      SessionOps.ensure_active!(tx)
-      raise Error, "transaction is already open" if tx.open?
+    def run(transaction)
+      SessionOps.ensure_active!(transaction)
+      raise Error, 'transaction is already open' if transaction.open?
 
-      conn = SessionOps.connection(tx)
-      conn.exec("BEGIN")
-      tx.__send__(:open=, true)
+      conn = SessionOps.connection(transaction)
+      conn.exec('BEGIN')
+      transaction.__send__(:open=, true)
       begin
-        result = yield tx
+        result = yield transaction
         commit(conn)
-        tx.__send__(:open=, false)
+        transaction.__send__(:open=, false)
         result
       rescue Exception
-        rollback_quietly(tx)
+        rollback_quietly(transaction)
         raise
       end
     end
 
     def commit(conn)
-      conn.exec("COMMIT")
-    rescue PG::Error => error
-      raise unless indeterminate_commit_failure?(conn, error)
+      conn.exec('COMMIT')
+    rescue PG::Error => e
+      raise unless indeterminate_commit_failure?(conn, e)
 
       raise IndeterminateCommitError.new(
-        "COMMIT acknowledgement was not received; the transaction may have committed " \
-        "and must not be retried blindly (#{error.class}: #{error.message})"
-      ), cause: error
+        'COMMIT acknowledgement was not received; the transaction may have committed ' \
+        "and must not be retried blindly (#{e.class}: #{e.message})"
+      ), cause: e
     end
 
     def indeterminate_commit_failure?(conn, error)
       return true if defined?(PG::ConnectionBad) && error.is_a?(PG::ConnectionBad)
+      return false unless conn.respond_to?(:finished?) && conn.respond_to?(:status)
       return true if conn.finished?
 
       conn.status != PG::CONNECTION_OK
     rescue PG::Error
       true
-    rescue NoMethodError
-      false
     end
 
-    def savepoint(tx, name)
-      SessionOps.ensure_active!(tx)
-      raise Error, "savepoint requires an open transaction" unless tx.open?
+    def savepoint(transaction, name)
+      SessionOps.ensure_active!(transaction)
+      raise Error, 'savepoint requires an open transaction' unless transaction.open?
 
-      conn = SessionOps.connection(tx)
-      seq = tx.__send__(:savepoint_seq) + 1
-      tx.__send__(:savepoint_seq=, seq)
+      conn = SessionOps.connection(transaction)
+      seq = transaction.__send__(:savepoint_seq) + 1
+      transaction.__send__(:savepoint_seq=, seq)
       point = name || "pgp_sp_#{seq}"
       ident = conn.quote_ident(point)
       conn.exec("SAVEPOINT #{ident}")
       begin
-        result = yield tx
+        result = yield transaction
         conn.exec("RELEASE SAVEPOINT #{ident}")
         result
       rescue Exception
-        rollback_to_savepoint(tx, ident)
+        rollback_to_savepoint(transaction, ident)
         raise
       end
     end
 
-    def rollback_to_savepoint(tx, ident)
-      conn = SessionOps.connection(tx)
+    def rollback_to_savepoint(transaction, ident)
+      conn = SessionOps.connection(transaction)
       return unless conn
 
       conn.exec("ROLLBACK TO SAVEPOINT #{ident}")
@@ -100,15 +99,15 @@ module PgPipeline
       nil
     end
 
-    def rollback_quietly(tx)
-      return unless tx.open?
+    def rollback_quietly(transaction)
+      return unless transaction.open?
 
-      conn = SessionOps.connection(tx)
-      conn&.exec("ROLLBACK")
+      conn = SessionOps.connection(transaction)
+      conn&.exec('ROLLBACK')
     rescue PG::Error
       nil
     ensure
-      tx.__send__(:open=, false)
+      transaction.__send__(:open=, false)
     end
   end
 end

data/lib/pg_pipeline/type_maps.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "pg"
-require_relative "errors"
+require 'pg'
+require_relative 'errors'
 
 module PgPipeline
   class TypeMaps
@@ -40,47 +40,62 @@ module PgPipeline
     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)
+      build_bundle(connection_args)
     rescue StandardError => e
       @bundle = :failed
       @text_map_for_results = nil
       raise Error, "failed to build CoderMapsBundle (#{e.class}: #{e.message})"
+    end
+
+    private
+
+    def build_bundle(connection_args)
+      conn = open_connection(connection_args)
+      @bundle = PG::BasicTypeRegistry::CoderMapsBundle.new(conn)
+      @text_map_for_results = PG::BasicTypeMapForResults.new(@bundle)
     ensure
-      begin
-        conn&.close
-      rescue StandardError
-        nil
-      end
+      close_connection(conn)
     end
 
+    def open_connection(connection_args)
+      return PG::Connection.new if connection_args.nil?
+
+      PG::Connection.new(connection_args)
+    end
+
+    def close_connection(conn)
+      conn&.close
+    rescue StandardError
+      nil
+    end
+
+    public
+
     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
+      map = resolve_type_map(request, result, map)
+      request.type_map = map if request.type_map.equal?(PENDING)
 
       result.type_map = map
     end
 
     private
 
+    def resolve_type_map(request, result, map)
+      return map unless map.equal?(PENDING)
+
+      name = request.statement_name
+      @cache[name] ||= build_column_map!(result)
+    end
+
     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"
+        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)"
+        raise Error, 'typed result mapping is unavailable (CoderMapsBundle failed)'
       end
 
       @text_map_for_results.build_column_map(result)

data/lib/pg_pipeline/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_pipeline
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Roman Hajdarov