pgx 1.0.4 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '02338571ec666c08713d25e4aa87b8ae7ff0ad9a153615db8c242d0d59450f1c'
-  data.tar.gz: 17c398d0f872f428203497dcc83111fe996f8b58372ed927c3336ea9f875df90
+  metadata.gz: 6d32046f29c429a8e7c9e45ec0d603fd96a2588a18bbe14d773a355e2e37e061
+  data.tar.gz: 28e35690b03970729e9ea98080473f90ada24435089237775d3e3c8275515aa6
 SHA512:
-  metadata.gz: b3090b8d4b06143e946437d0074dcf06f105d338bb9c70b7aeddc5cab3fc5da82545b39de8eb4f189d53ef8d8fae464a66f32a17a2c37abc6ff11ce89446fd21
-  data.tar.gz: 13650f36b6a5a1b3b323d2c9dbea6b7df00a8d8bd8c0fd22241e5b12a3a39853b318e4bda88ada8e73e715a8746db42c74439164c70796d1ca6e8cdf7d7cd4e3
+  metadata.gz: 9b5bc92e8d2b851dd43b668ab278d7129dac7e7dd6fa9d18800d4f644d376b345a2dae37392629cc10f0bda979adb0deaff40cfee43d920ebf17dc650725b3cc
+  data.tar.gz: e43a561b2ec0dc3e5202d7774a52ad145a80ae543b0d7e52fb83273eb250c1ca08040c49b42be1f94e7249fb209b97530ad25deefc9a56594a97ef7814979544

data/lib/pgx.rb

@@ -37,15 +37,13 @@ module PGx
     )
 
     # @author Kiriakos Georgiou, http://www.mockbites.com/about
-    # Extends the base class PG::Connection methods by adding logging and
+    # Extends the PG::Connection methods by adding logging and
     # retrying capabilities (synchronous methods only.)
     # The arguments and method behaviors are
     # identical, except for the 'new' method.
     # @see http://www.mockbites.com/articles/tech/pgx pgx documentation
     # @see http://deveiate.org/code/pg/PG/Connection.html Base class methods
-    class PGx::Connection < PG::Connection
-        alias PG_close close # for use when closing bad connections
-
+    class PGx::Connection
         # @param [Logger] logger: a logger object, or a lambda returning the
         #   logger object.  Note that a lambda returning the logger is
         #   preferable because it makes logging of the log object itself
@@ -87,7 +85,7 @@ module PGx
         #   )
         def initialize(*args)
             connect_args = PGx.const_get('CONNECT_ARGS')
-            (our_args, parent_args) = extract_our_args(connect_args, args)
+            (our_args, pg_args) = extract_our_args(connect_args, args)
 
             log = arg_with_default(connect_args, our_args, :logger)
             @logger = [ log.is_a?(Proc) ? log.call : log ].flatten
@@ -112,47 +110,29 @@ module PGx
             @connect_proc = lambda {
                 @prepared_live = {} # reset on connect
                 connect_log_and_try(
-                    lambda { super(*parent_args) },
+                    lambda { PG::Connection.new(*pg_args) },
                     our_args,
-                    parent_args
+                    pg_args
                 )
             }
             connect_loop()
         end
 
+        def method_missing(m, *args, &block)
+            sql_log_and_try(lambda { @connection.send(m, *args, &block) }, m, args)
+        end
+
         # @example
         #   con.transaction do
         #       con.exec "create temp table mytable(x text)"
         #       con.exec "insert into mytable(x) values('a')"
         #       con.exec "insert into mytable(x) values('b')"
         #   end
-        def transaction(*args)
+        def transaction(*args, &block)
             @in_transaction_block = true
-            sql_log_and_try(lambda { super }, __method__, args)
+            r = sql_log_and_try(lambda { @connection.transaction(*args, &block) }, __method__, args)
             @in_transaction_block = false
-        end
-
-        # @example
-        #   con.exec "insert into mytable(x) values('test value')"
-        #   con.exec 'insert into mytable(x) values($1)', ['test value']
-        def exec(*args)
-            sql_log_and_try(lambda { super }, __method__, args)
-        end
-
-        # Alias for exec
-        def query(*args)
-            sql_log_and_try(lambda { super }, __method__, args)
-        end
-
-        # @example
-        #   con.exec_params 'select * from mytable where x = $1 limit $2', [1, 100] do |rs|
-        #       puts rs.fields.collect { |fname| "%-15s" % [fname] }.join('')
-        #       rs.values.collect { |row|
-        #           puts row.collect { |col| "%-15s" % [col] }.join('')
-        #       }
-        #   end
-        def exec_params(*args)
-            sql_log_and_try(lambda { super }, __method__, args)
+            r
         end
 
         # @example
@@ -163,52 +143,27 @@ module PGx
         #           puts row.collect { |col| "%-15s" % [col] }.join('')
         #       }
         #   end
-        def prepare(*args)
+        def prepare(*args, &block)
             # it's possible to call prepare() on an statement that is already prepared
             # if you have a prepare() inside a transaction, and the transaction is retried
             # thus we check if it's already live
             s = args[0]
+            r = nil
             if @prepared_live.has_key?(s)
                 log_debug %Q{prepared statement #{s} is already live, skipping re-preparing it}
             else
-                sql_log_and_try(lambda { super }, __method__, args)
+                r = sql_log_and_try(lambda { @connection.prepare(*args, &block) }, __method__, args)
                 @prepared_statements[s] = args[1]
                 @prepared_live[s] = true
             end
+            r
         end
 
-        # @example
-        #   con.prepare 'sql1', 'select * from mytable limit $1'
-        #   con.exec_prepared 'sql1', [100] do |rs|
-        #       puts rs.fields.collect { |fname| "%-15s" % [fname] }.join('')
-        #       rs.values.collect { |row|
-        #           puts row.collect { |col| "%-15s" % [col] }.join('')
-        #       }
-        #   end
-        def exec_prepared(*args)
-            sql_log_and_try(lambda { super }, __method__, args)
-        end
-
-        def cancel(*args)
-            sql_log_and_try(lambda { super }, __method__, args)
-        end
-
-        def close(*args)
-            sql_log_and_try(lambda { super }, __method__, args)
-        end
-
-        def finish(*args)
-            sql_log_and_try(lambda { super }, __method__, args)
-        end
-
-        def reset(*args)
-            sql_log_and_try(lambda { super }, __method__, args)
+        def reset(*args, &block)
+            r = sql_log_and_try(lambda { @connection.reset(*args, &block) }, __method__, args)
             @prepared_live = {} # reset on connect
             @connect_init.call(@connection)
-        end
-
-        def wait_for_notify(*args)
-            sql_log_and_try(lambda { super }, __method__, args)
+            r
         end
 
         private
@@ -221,7 +176,7 @@ module PGx
 
         # extract our arguments defined in all_our_possible_args from args
         # returns an array containing our arguments (hash) and the aguments
-        # for the parent method
+        # for the pg method
         def extract_our_args(all_our_possible_args, args)
             our_args = {}
             if args[0].is_a?(Hash)
@@ -280,45 +235,45 @@ module PGx
             end
         end
 
-        # sanitize parent arguments, eg: blank the password so it's not in the logs
-        def sanitize_parent_connect_args(parent_args)
-            if parent_args.empty?
-                return parent_args
-            elsif parent_args.length == 1
-                if parent_args[0].is_a?(Hash) # hash method
-                    return [ parent_args[0].merge(parent_args[0]) { |k, ov| k == :password ? '...' : ov } ]
+        # sanitize pg arguments, eg: blank the password so it's not in the logs
+        def sanitize_pg_connect_args(pg_args)
+            if pg_args.empty?
+                return pg_args
+            elsif pg_args.length == 1
+                if pg_args[0].is_a?(Hash) # hash method
+                    return [ pg_args[0].merge(pg_args[0]) { |k, ov| k == :password ? '...' : ov } ]
                 end
-                if parent_args[0].is_a?(String) # string method
-                    return [ parent_args[0].gsub(/(password\s*=\s*)\S+/, '\1...') ]
+                if pg_args[0].is_a?(String) # string method
+                    return [ pg_args[0].gsub(/(password\s*=\s*)\S+/, '\1...') ]
                 end
             else # positional arguments method
-                return [ parent_args.map.with_index { |x, i| i == 6 ? '...' : x } ]
+                return [ pg_args.map.with_index { |x, i| i == 6 ? '...' : x } ]
             end
         end
 
         # merge as follows:
         #   hash and hash -> hash
         #   hash and array -> array
-        def merge_connect_args(our_args, parent_args)
+        def merge_connect_args(our_args, pg_args)
             if our_args.empty?
-                return parent_args
-            elsif parent_args.empty?
+                return pg_args
+            elsif pg_args.empty?
                 return our_args
-            elsif parent_args.length == 1 and parent_args[0].is_a?(Hash)
-                return our_args.merge(parent_args[0]) # connection hash style
+            elsif pg_args.length == 1 and pg_args[0].is_a?(Hash)
+                return our_args.merge(pg_args[0]) # connection hash style
             else
-                return [our_args].concat(parent_args)
+                return [our_args].concat(pg_args)
             end
         end
 
         # log and retry the connect/new method
-        def connect_log_and_try(caller_super, our_args, parent_args)
+        def connect_log_and_try(pg_lambda, our_args, pg_args)
             try_count = 0
             all_args = merge_connect_args( sanitize_our_connect_args(our_args),
-                                           sanitize_parent_connect_args(parent_args) )
+                                           sanitize_pg_connect_args(pg_args) )
             begin
                 log_debug function_call_string('connect', all_args)
-                @connection = caller_super.call # run the parent 'pg' function, new()
+                @connection = pg_lambda.call # run pg new() mathod
                 log_debug 'calling connection initialization proc'
                 @connect_init.call(@connection)
             rescue PG::Error => e
@@ -336,25 +291,25 @@ module PGx
         end
 
         # log and retry statement related methods
-        def sql_log_and_try(caller_super, caller_method, args)
+        def sql_log_and_try(pg_lambda, method, args)
             try_count = 0
             begin                                     # re-prepare prepared statements after a failed transaction
-                transaction_reprepare(caller_method)  # just prior to retrying the transaction
-                log_debug function_call_string(caller_method, args)
-                caller_super.call # run the parent 'pg' function
+                transaction_reprepare(method)         # just prior to retrying the transaction
+                log_debug function_call_string(method, args)
+                pg_lambda.call # run the pg method
             rescue PG::Error => e
                 if connected? # if we are connected, it's an SQL related error
-                    if not method_in_transaction_block(caller_method)                # do not log errors and retry
+                    if not method_in_transaction_block(method)                       # do not log errors and retry
                         try_count = try_count + 1                                    # methods within a transaction
                         log_error(get_error_fields(e) + "\n" + get_error_message(e)) # block because the transaction
-                        error_handlers(e, caller_method, args)                       # itself will log the error and
+                        error_handlers(e, method, args)                              # itself will log the error and
                         retry if sql_retriable?(e, try_count)                        # retry the transaction block
-                    elsif caller_method.to_s == 'exec_prepared' # exec_prepared failed within a transaction
+                    elsif method.to_s == 'exec_prepared'        # exec_prepared failed within a transaction
                         @transaction_reprepare = args[0]        # make a note to re-prepare before retrying
                     end                                         # the transaction
                 else # not connected
                     log_warn 'bad database connection'
-                    #PG_close()
+                    @connection.close # just in case so we don't leak connections
                     connect_loop()
                     retry
                 end
@@ -363,7 +318,7 @@ module PGx
         end
 
         # special handling of certain error states (not in a transaction)
-        def error_handlers(pgerr, caller_method, args)
+        def error_handlers(pgerr, method, args)
             begin
                 state = pgerr.result.error_field(PG::Result::PG_DIAG_SQLSTATE)
             rescue PG::Error => e
@@ -372,12 +327,12 @@ module PGx
 
             case state
                 when '26000'
-                    reprepare_statement(args[0]) if caller_method.to_s == 'exec_prepared'
+                    reprepare_statement(args[0]) if method.to_s == 'exec_prepared'
             end # case
         end
 
-        def transaction_reprepare(caller_method)
-            if caller_method.to_s == 'transaction' and not @transaction_reprepare.nil?
+        def transaction_reprepare(method)
+            if method.to_s == 'transaction' and not @transaction_reprepare.nil?
                 reprepare_statement(@transaction_reprepare)
                 @transaction_reprepare = nil
             end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: pgx
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.7
 platform: ruby
 authors:
 - Kiriakos Georgiou
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-18 00:00:00.000000000 Z
-dependencies: []
+date: 2023-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: |2
           A pure ruby "thin" extension of pg that provides logging,
           transaction retrying, and database reconnecting functionality.
@@ -23,7 +37,7 @@ homepage: http://www.mockbites.com/articles/tech/pgx
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -38,8 +52,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
 summary: A thin extension of pg
 test_files: []