pg_conn 0.35.0 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4c942ce055688931946e0d5a71ddc89a722b2dd98ea6d9d0edc150b39421dd9
-  data.tar.gz: 3fea9a99e361c86b3b413845d5f319562051347afe025a27006c80548f822ff4
+  metadata.gz: 3d6940809a3f62bfad5cd2a94566a76bcd1944ad5b6ded6df2be159a010b2169
+  data.tar.gz: 6f213cb288ba5a85205fd5054fb498e6200b0319eee8c2bbc8c60515705410f7
 SHA512:
-  metadata.gz: aa391cc15005c51ca01503e33096dacecec5743fa3bf6f28c22d7fd2ad7e14d2e23f48dc2cc0e3e9cade6d77bc359d3b56ebb871015e2db9d08cffcedcf8988f
-  data.tar.gz: 6fd5537fe417a8dac42ad2ac3af16c75a329bcafc93118ae2a375a3ec3368d0dc088163f8dbd87d5b56a8cb357b3bc5c76c6f9ec49618d4d4c6099bee472b423
+  metadata.gz: a90dab6c75eb2cfd7a99b39676a4aa0dc167462e37e9229d96ed30517b4ff0c691f6b4389ceb6d26c3f2562d7ce4e7dd2be17d054f1e61369989fb9f8c3db8e1
+  data.tar.gz: f91893227ef9697eb236051728d509727b2d20b5d9efd7c6f848cf2e887b1abc0e5c8a48da291914372049ab25aee6580b9b74fd422d269c3e7813928032dd23

data/lib/pg_conn/version.rb

@@ -1,3 +1,3 @@
 module PgConn
-  VERSION = "0.35.0"
+  VERSION = "0.36.0"
 end

data/lib/pg_conn.rb

@@ -40,22 +40,22 @@ module PgConn
   #
   def self.quote_identifier(s)
     s = s.to_s if s.is_a?(Symbol)
-    escape_identifier(s).gsub(/\./, '"."').sub(/"\*"/, "*")
+    Literal.new escape_identifier(s).gsub(/\./, '"."').sub(/"\*"/, "*")
   end
 
   # Quote identifiers and concatenate them using ',' as separator
-  def self.quote_identifiers(idents) = idents.map { |ident| quote_identifier(ident) }.join(", ")
+  def self.quote_identifiers(idents) = Literal.new idents.map { |ident| quote_identifier(ident) }.join(", ")
 
-  # Quote the value as a string. Emit 'null' if value is nil
+  # Quote the value as a string. Returns a Literal object
   #
   # The value can be of any type but is converted to a string using #to_s
   # before quoting. This works by default for the regular types Integer,
   # true/false, Time/Date/DateTime, and arrays. Other types may require
   # special handling
   #
-  # Hashes are quoted as a literal JSON expression. The result is a string
-  # and it is the application's responsibility to cast them to either 'json'
-  # or 'jsonb'
+  # Hashes are quoted as a literal JSON expression converted into the given
+  # :json_type. If :json_type is nil, it is the application's responsibility to
+  # cast the value to either 'json' or 'jsonb'
   #
   # Note that a tuple value (an array) must be quoted using #quote_tuple
   # because #quote_value would quote the tuple as an array value instead of a
@@ -66,48 +66,51 @@ module PgConn
   # type when the argument is an empty array. It is not needed if the array
   # is guaranteed to be non-empty. Nested arrays are not supported
   #
-  def self.quote_value(value, elem_type: nil)
-    case value
-      when Literal; value
-      when String; escape_literal(value)
-      when Integer, Float; value.to_s
-      when true, false; value.to_s
-      when nil; 'null'
-      when Date, DateTime; "'#{value}'"
-      when Time; "'#{value.strftime("%FT%T%:z")}'"
-      when Array
-        if value.empty?
-          elem_type or raise Error, "Empty array without elem_type"
-          "array[]::#{elem_type}[]"
+  def self.quote_value(value, elem_type: nil, json_type: nil)
+    Literal.new \
+        case value
+          when Literal; value
+          when String; escape_literal(value)
+          when Integer, Float; value.to_s
+          when true, false; value.to_s
+          when nil; 'null'
+          when Date, DateTime; "'#{value}'"
+          when Time; "'#{value.strftime("%FT%T%:z")}'"
+          when Array
+            if value.empty?
+              elem_type or raise Error, "Empty array without elem_type"
+              "array[]::#{elem_type}[]"
+            else
+              "array[#{value.map { |elem| quote_value(elem) }.join(', ')}]"
+            end
+          when Hash; ["'#{value.to_json}'", json_type].compact.join('::')
         else
-          "array[#{value.map { |elem| quote_value(elem) }.join(', ')}]"
+          escape_literal(value.to_s)
         end
-      when Hash; "'#{value.to_json}'"
-    else
-      escape_literal(value.to_s)
-    end
   end
 
   # Quote values and concatenate them using ',' as separator
-  def self.quote_values(values, elem_type: nil)
-    values.map { |value| quote_value(value, elem_type: elem_type) }.join(", ")
+  def self.quote_values(values, **opts)
+    Literal.new values.map { |value| quote_value(value, **opts) }.join(", ")
   end
 
   # Quote an array of values as a tuple. The element types should be in the
   # same order as the array arguments. #quote_tuples is same as #quote_values
   # except the values may have different types (this makes no difference
   # except in the case when the tuple may contain empty array(s))
-  def self.quote_tuple(tuple, elem_types: nil)
+  #
+  # Note that it is :elem_types (plural) and not :elem_type
+  def self.quote_tuple(tuple, elem_types: nil, **opts)
     elem_types = Array(elem_types)
-    tuple.map { |value|
+    Literal.new tuple.map { |value|
       elem_type = value.is_a?(Array) ? elem_types&.shift : nil
-      quote_value(value, elem_type: elem_type)
+      quote_value(value, **opts, elem_type: elem_type)
     }.join(", ")
   end
 
   # Quote an array of tuples
-  def self.quote_tuples(tuples, elem_types: nil)
-    tuples.map { |tuple| "(#{quote_tuple(tuple, elem_types: elem_types)})" }.join(", ")
+  def self.quote_tuples(tuples, **opts)
+    Literal.new tuples.map { |tuple| "(#{quote_tuple(tuple, **opts)})" }.join(", ")
   end
 
   # Used to mark strings as literals that should not be quoted. This is the
@@ -125,6 +128,9 @@ module PgConn
     # The class of column names (Symbol or String). Default is Symbol
     attr_reader :field_name_class
 
+    # Default postgres JSON type (either 'json' or 'jsonb'). Default is 'jsonb'
+    attr_reader :default_json_type
+
     # Name of user
     def user() @pg_connection.user end
     alias_method :username, :user # Obsolete FIXME Is it?
@@ -155,28 +161,56 @@ module PgConn
     # #exec or #transaction block. The timestamp includes the current time zone
     attr_reader :timestamptz
 
-    # Controls error messages. It can be assigned true, false, nil. True causes
-    # the error message to be printed to standard error, false ignores it, and
-    # nil resets the state to the default given when the connection was
-    # initialized or false if absent. Note that #silent only controls the error
-    # message, the exception is not affected
+    # Controls error messages. It can be assigned true, false, nil, or a Proc
+    # object that recieves the message. True causes the message to be printed
+    # to standard error, false ignores it, and nil resets the state to the
+    # default given when the connection was initialized. #silent? returns true
+    # if #silent is false or a Proc object and should be used instead #silent
+    # to check the state because #silent returns truish when output is
+    # redirected to a Proc
+    #
+    # Note that #silent=, #notice=, and warning= only controls the error
+    # message, the exception is passed through unaltered
+    #
     def silent() @options[:silent] end
+    def silent?() @producers[:silent].nil? end # silent == false/Proc is true
     def silent=(value) set_option(:silent, value) end
 
-    # Controls notices. It can be assigned true, false, nil, or a Proc object
-    # that recieves the message. True causes the message to be printed to
-    # standard output, false ignores it, and nil resets the state to the
-    # default given when the connection was initialized or false if absent
-    def notice() @options[:notice] end
-    def notice=(value) set_option(:notice, value) end
-
     # Controls warnings. It can be assigned true, false, nil, or a Proc object
     # that recieves the message. True causes the message to be printed to
     # standard error, false ignores it, and nil resets the state to the default
-    # given when the connection was initialized or false if absent
+    # given when the connection was initialized
     def warning() @options[:warning] end
+    def warning?() !warning.nil? end
     def warning=(value) set_option(:warning, value) end
 
+    # Controls notice messages. It can be assigned true, false, nil, or a Proc
+    # object that recieves the message. True causes the message to be printed
+    # to standard error, false ignores it, and nil resets the state to the
+    # default given when the connection was initialized. Default false
+    def notice() @options[:notice] end
+    def notice?() !notice.nil? end
+    def notice=(value) set_option(:notice, value) end
+
+    # Controls info messages. It can be assigned true, false, nil, or a Proc
+    # object that recieves the message. True causes the message to be printed
+    # to standard output, false ignores it, and nil resets the state to the
+    # default given when the connection was initialized. Default false. Note
+    # that #info is the only level that outputs to standard output
+    def info() @options[:info] end
+    def info?() !info.nil? end
+    def info=(value) set_option(:info, value) end
+
+    # Controls debug messages. It can be assigned true, false, nil, or a Proc
+    # object that recieves the message. True causes the message to be printed
+    # to standard error, false ignores it, and nil resets the state to the
+    # default given when the connection was initialized. Default false
+    def debug() @options[:debug] end
+    def debug?() !debug.nil? end
+    def debug=(value) set_option(:debug, value) end
+
+    DEFAULT_OPTIONS = { silent: false, warning: true, notice: false, info: false, debug: false }
+
     # TODO: Move error message handling into the same framework as notice and
     # warning but we have a name collision just below that would need to be
     # resolved somehow
@@ -214,8 +248,6 @@ module PgConn
     # if absent in the Postgres error message
     def errchar = err[2]
 
-    DEFAULT_OPTIONS = { silent: false, notice: false, warning: false }
-
     # :call-seq:
     #     initialize(dbname = nil, user = nil, **options)
     #     initialize(connection_hash, **options)
@@ -247,8 +279,10 @@ module PgConn
     # Symbol (the default) or String. The :timestamp option is used
     # internally to set the timestamp for transactions
     #
-    # The :notice and :warning options sets the default output handling this
-    # connection (FIXME fails on copied connections)
+    # The :notice and :warning options sets the default output handling for this
+    # connection (FIXME fails on copied connections). Default is to suppress
+    # notices and lower - this is diffent from postgres that by default include
+    # notices
     #
     # Note that the connection hash and the connection string may support more
     # parameters than documented here. Consult
@@ -263,7 +297,17 @@ module PgConn
       if args.last.is_a?(Hash)
         opts = args.last
         @field_name_class = opts.delete(:field_name_class) || Symbol
-        options = DEFAULT_OPTIONS.transform_values! { |k,v| opts.key?(k) ? opts.delete(k) : v }
+
+        # Extract options from arguments
+        options = DEFAULT_OPTIONS.to_h { |k,v|
+          r = if opts.key?(k)
+            value = opts.delete(k)
+            value.nil? ? v : value
+          else
+            v
+          end
+          [k, r]
+        }
 
         # FIXME: Is this used?
         @timestamp = opts.delete(:timestamp)
@@ -272,7 +316,7 @@ module PgConn
         args.pop if opts.empty?
       else
         @field_name_class = Symbol
-        options = DEFAULT_OPTIONS
+        options = DEFAULT_OPTIONS.dup
       end
 
 #     else # We assume that the current user is a postgres superuser
@@ -340,11 +384,17 @@ module PgConn
         @pg_connection.field_name_type = @field_name_class.to_s.downcase.to_sym # Use symbol field names
       end
 
-      # Set options even if there is no connection to avoid special casing
-      # absent options
-      @options, @default_options = {}, DEFAULT_OPTIONS.merge(options)
-      set_options(options) if @pg_connection
-
+      # Set options. The initial options also serves as default values and are
+      # themselves initialized using DEFAULT_VALUES
+      #
+      # Note that options is initialized even if there is no connection to
+      # avoid special casing
+      @default_options = options
+      @options = {}
+      @producers = {} # Map from message level to Proc or nil
+      set_options(@default_options) if @pg_connection
+
+      @default_json_type = :jsonb
       @schema = SchemaMethods.new(self)
       @role = RoleMethods.new(self)
       @rdbms = RdbmsMethods.new(self)
@@ -380,17 +430,17 @@ module PgConn
       end
     end
 
-    # Mark argument as already being quoted. TODO: Make this the default in all
-    # quote methods
+    # Mark string argument as already being quoted
     def literal(arg) Literal.new(arg) end
 
     # Connection member method variations of the PgConn quote class methods
+    # with at least a default value for :json_type
     def quote_identifier(s) = PgConn.quote_identifier(s)
     def quote_identifiers(idents) = PgConn.quote_identifiers(idents)
-    def quote_value(value, **opts) = PgConn.quote_value(value, **opts)
-    def quote_values(values, **opts) = PgConn.quote_values(values, **opts)
-    def quote_tuple(tuple, **opts) = PgConn.quote_tuple(tuple, **opts)
-    def quote_tuples(tuples, **opts) = PgConn.quote_tuples(tuples, **opts)
+    def quote_value(value, **opts) = PgConn.quote_value(value, json_type: self.default_json_type, **opts)
+    def quote_values(values, **opts) = PgConn.quote_values(values, json_type: self.default_json_type, **opts)
+    def quote_tuple(tuple, **opts) = PgConn.quote_tuple(tuple, json_type: self.default_json_type, **opts)
+    def quote_tuples(tuples, **opts) = PgConn.quote_tuples(tuples, json_type: self.default_json_type, **opts)
 
     # Quote a record and cast it into the given type, the type can also be a
     # table or view. 'data' is an array, hash, or struct representation of the
@@ -403,14 +453,14 @@ module PgConn
     #
     # Also note that there is not class-method variant of this method because
     # it requires a connection
-    def quote_record(data, schema_name = nil, type, elem_types: nil)
-      quote_record_impl(data, schema_name, type, elem_types: elem_types, array: false)
+    def quote_record(data, schema_name = nil, type, **opts)
+      quote_record_impl(data, schema_name, type, array: false, **opts)
     end
 
     # Quote an array of records. The type is the record type, not the type of
     # the enclosing array
-    def quote_records(data, schema_name = nil, type, elem_types: nil)
-      quote_record_impl(data, schema_name, type, elem_types: elem_types, array: true)
+    def quote_records(data, schema_name = nil, type, **opts)
+      quote_record_impl(data, schema_name, type, array: true, **opts)
     end
 
     # :call-seq:
@@ -692,11 +742,11 @@ module PgConn
     # columns (like #tuples).
     #
     # The name argument can be a String or a Symbol that may contain the schema
-    # of the function.  If the :proc option is true the "function" is assumed
+    # of the function. If the :proc option is true the "function" is assumed
     # to be a procedure
     #
-    def call(name, *args, elem_type: nil, silent: self.silent, proc: false) # :proc may interfere with hashes
-      args_seq = quote_values(args, elem_type: elem_type)
+    def call(name, *args, silent: self.silent, proc: false, **opts) # :proc may interfere with hashes
+      args_seq = quote_values(args, **opts)
       if proc
         pg_exec "call #{name}(#{args_seq})", silent: silent
         return nil
@@ -719,8 +769,8 @@ module PgConn
     end
 
     # Like #call with :proc set to true
-    def proc(name, *args, silent: self.silent)
-      call(name, *args, silent: silent, proc: true)
+    def proc(name, *args, json_type: self.default_json_type, silent: self.silent)
+      call(name, *args, silent: silent, proc: true, json_type: json_type)
     end
 
     # :call-seq:
@@ -859,7 +909,14 @@ module PgConn
     #
     # TODO: Make sure the transaction stack is emptied on postgres errors
     def exec(sql, commit: true, fail: true, silent: self.silent)
-      transaction(commit: commit) { execute(sql, fail: fail, silent: silent) }
+      transaction(commit: commit) {
+        begin
+          execute(sql, fail: fail, silent: silent)
+        rescue PG::Error
+          cancel_transaction
+          raise
+        end
+      }
     end
 
     # Like #exec but returns true/false depending on if the command succeeded,
@@ -888,7 +945,6 @@ module PgConn
         begin
           pg_exec(sql, silent: silent)&.cmd_tuples
         rescue PG::Error
-          cancel_transaction
           raise if fail
           return nil
         end
@@ -954,9 +1010,9 @@ module PgConn
         # file instead of being executed. Maybe remove logging (or execute always
         # and log as a side-effect)
         if @pg_connection
-            @timestamp, @timestamptz = @pg_connection.exec(
-                'select current_timestamp::timestamp without time zone, current_timestamp'
-            ).tuple_values(0)
+          @timestamp, @timestamptz = @pg_connection.exec(
+              'select current_timestamp::timestamp without time zone, current_timestamp'
+          ).tuple_values(0)
         end
       end
     end
@@ -987,9 +1043,16 @@ module PgConn
     # progress, the method always succeeds
     def cancel_transaction
       begin
-        pg_exec("rollback")
+        # The transaction may be invalid to we can't use #set_option to silence
+        # warnings when the transaction is rolled back. Instead we manipulate the
+        # procudure method
+        saved_producer = @producers[:warning]
+        @producers[:warning] = nil
+        pg_exec("rollback", silent: true)
       rescue PG::Error
         ;
+      ensure
+        @producers[:warning] = saved_producer
       end
       @savepoints = nil
       true
@@ -1018,7 +1081,6 @@ module PgConn
           return nil
         rescue PG::Error
           cancel_transaction
-          @savepoints = nil
           raise
         end
         pop_transaction(commit: commit, fail: false)
@@ -1093,16 +1155,18 @@ module PgConn
     end
 
     # Common implementation for #quote_record and #quote_records that avoids
-    # querying the database multiple times or duplication the code. The :array
-    # flag is true when called via #quote_records
+    # querying the database multiple times or duplication the code
     #
     # @data can be a Hash, Array, or OpenStruct. Hash keys must be symbols or
     # strings, they belong to the same namespace so :k and "k" refer to the
-    # same value
+    # same value. The :array flag is true when called via #quote_records
     #
     # Note that #quote_record_impl queries the database for information about
     # the type. TODO Cache this information?
-    def quote_record_impl(datas, schema_name = nil, type, elem_types: nil, array: nil)
+    #
+    def quote_record_impl(datas, schema_name = nil, type, elem_types: nil, array: nil, **opts)
+      datas = [datas] if !array
+
       pg_type = [schema_name, type].compact.join('.')
       fields = self.values(%(
         select attname
@@ -1114,8 +1178,6 @@ module PgConn
         order by attnum
       )).map(&:to_sym)
 
-      datas = [datas] if !array
-
       literals = datas.map { |data|
         values =
             case data
@@ -1125,20 +1187,19 @@ module PgConn
             else
               raise Error, "Illegal value #{data.inspect}"
             end
-        "(#{quote_tuple(values, elem_types: elem_types)})::#{pg_type}"
+        "(#{quote_tuple(values, elem_types: elem_types, **opts)})::#{pg_type}"
       }
 
       if array
-        "array[#{literals.join(', ')}]::#{pg_type}[]"
+        Literal.new "array[#{literals.join(', ')}]::#{pg_type}[]"
       else
-        literals.first
+        Literal.new literals.first
       end
     end
 
     # :call-seq
     #   parse_query(query)
     #   parse_query(table, id, fields...)
-    #   parse_query(table, where_clause, fields...)
     #   parse_query(table, hash, fields...)
     #   parse_query(table, fields...)
     #
@@ -1172,45 +1233,58 @@ module PgConn
     end
 
     STDOUT_PRODUCER = lambda { |msg| $stdout.puts msg }
-    STDERR_PRODUCER = lambda { |msg| $stderr.puts msg }
+    STDERR_PRODUCER = lambda { |msg| $stderr.puts msg; $stderr.flush }
+    ERROR_PRODUCER = lambda { |msg, stmt| $stderr.puts stmt, nil, msg; $stderr.flush }
+
+    # Map from message level to default producer. Note that we rely on the key
+    # order to determine the minimum message level in #set_option below
+    DEFAULT_PRODUCER = {
+      debug: STDERR_PRODUCER,
+      info: STDOUT_PRODUCER,
+      notice: STDERR_PRODUCER,
+      warning: STDERR_PRODUCER,
+      error: STDERR_PRODUCER
+    }
 
     # FIXME Fails if connection is copied - requires a common options object
     # that is shared between all connection copies
     def set_option(option, value)
+      # Assign default
+      value = @default_options[option] if value.nil?
+
+      # Find current message level
+      old_level = DEFAULT_PRODUCER.keys.find { |level| @producers[level] } || :error
+
+      # Set new value. Can be true, false, or a Proc object
+      @options[option] = value
+
+      # Set producer
       case option
         when :silent
-          @options[:silent] =
+          @producers[:silent] =
               case value
-                when true, false; value
-                when nil; @default_options[:silent]
+                when true; nil
+                when false; ERROR_PRODUCER
+                when Proc; value
               else
-                raise ArgumentError, "Illegal value #{value.inspect}"
+                raise ArgumentError, "Illegal value: #{value.inspect}"
               end
-        when :notice, :warning
-          @options[option] =
+        when :debug, :info, :notice, :warning
+          @producers[option] =
               case value
-                when true; option == :notice ? STDOUT_PRODUCER : STDERR_PRODUCER
+                when true; DEFAULT_PRODUCER[option]
                 when false; nil
-                when nil; @default_options[option]
                 when Proc; value
               else
                 raise ArgumentError, "Illegal value #{value.inspect}"
               end
-          enabled = !@options[option].nil?
-          if option == :notice
-            if enabled
-              @pg_connection.exec "set client_min_messages to notice"
-            elsif warning
-              @pg_connection.exec "set client_min_messages to warning"
-            else
-              @pg_connection.exec "set client_min_messages to error"
-            end
-          elsif !notice
-            if enabled
-              @pg_connection.exec "set client_min_messages to notice"
-            else
-              @pg_connection.exec "set client_min_messages to error"
-            end
+
+          # Find new message level
+          new_level = DEFAULT_PRODUCER.keys.find { |level| @producers[level] } || :error
+
+          # Adjust postgres message level if changed
+          if old_level != new_level
+            @pg_connection.exec "set client_min_messages to #{new_level}"
           end
       else
         raise ArgumentError, "Illegal option: #{option.inspect}"
@@ -1224,10 +1298,13 @@ module PgConn
     def get_options() @options.dup end
 
     # Called from postgres. Installed in #initialize
-    def message_processor(message)
+    def message_processor(message, stmt = nil)
       case message
-        when /^NOTICE:\s*(.*)$/; @options[:notice]&.call($1)
-        when /^WARNING:\s*(.*)$/; @options[:warning]&.call($1)
+        when /^DEBUG:\s*(.*)$/; @producers[:debug]&.call($1)
+        when /^INFO:\s*(.*)$/; @producers[:info]&.call($1)
+        when /^NOTICE:\s*(.*)$/; @producers[:notice]&.call($1)
+        when /^WARNING:\s*(.*)$/; @producers[:warning]&.call($1)
+        when /^ERROR:\s*(.*)$/m; @producers[:silent]&.call($1, stmt)
       else
         raise "Oops"
       end
@@ -1255,6 +1332,10 @@ module PgConn
     def pg_exec(arg, silent: self.silent)
       if @pg_connection
         begin
+          # Set silent state
+          saved_silent = self.silent
+          self.silent = silent
+
           last_stmt = nil # To make the current SQL statement visible to the rescue clause. FIXME Not used?
           if arg.is_a?(String)
             return nil if arg == ""
@@ -1272,12 +1353,11 @@ module PgConn
             @error = ex
             @err = nil
           end
-          if !silent # FIXME Why do we handle this?
-            $stderr.puts arg
-            $stderr.puts
-            $stderr.puts ex.message
-            $stderr.flush
-          end
+
+          # Process message before resetting silent state
+          message_processor(@error.message, arg)
+          self.silent = saved_silent
+
           raise
         end
 
@@ -1313,16 +1393,15 @@ module PgConn
   def self.sql_values(values) "'" + values.join("', '") + "'" end
   def self.sql_idents(values) '"' + values.join('", "') + '"' end
 
-    # Same as postgres PG#escape_literal but do not need a connection
-    def self.escape_literal(s) = s.nil? ? 'NULL' : "'#{s.gsub("'", "''")}'"
-
-    # Same as postgres PG#escape_identifier but do not need a connection
-    def self.escape_identifier(s)
-      !s.nil? or raise TypeError, "Identifier can't be nil"
-      s.is_a?(String) or raise TypeError, "Identifier can't be a #{s.class}"
-      s !~ /\A\s*\z/ or raise TypeError, "Identifier be blank"
-      %("#{s.gsub('"', '""')}")
-    end
+  # Same as postgres PG#escape_literal but do not need a connection
+  def self.escape_literal(s) = s.nil? ? 'NULL' : "'#{s.gsub("'", "''")}'"
 
+  # Same as postgres PG#escape_identifier but do not need a connection
+  def self.escape_identifier(s)
+    !s.nil? or raise TypeError, "Identifier can't be nil"
+    s.is_a?(String) or raise TypeError, "Identifier can't be a #{s.class}"
+    s !~ /\A\s*\z/ or raise TypeError, "Identifier be blank"
+    %("#{s.gsub('"', '""')}")
+  end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_conn
 version: !ruby/object:Gem::Version
-  version: 0.35.0
+  version: 0.36.0
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-11 00:00:00.000000000 Z
+date: 2025-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg