pg_conn 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28c2a6429f9c8e987f27686e323643baf77f4429599bfb457ecdd6d5b659a289
-  data.tar.gz: e8e2c96d92401a3eceff86b77152acdfe9019c03306577d260c6039d39881630
+  metadata.gz: 122b4fc4ba631ecac00021695532624fd13a578183812a98617a9f05b5a9104f
+  data.tar.gz: 02e3a823f17d4c6012a51186a2da124b0dfacf5ece0e4f8f5a6a6c31d97675d1
 SHA512:
-  metadata.gz: b6f08ca6bd0b47206623435dbf6691f0d8276fa5a8ac1c71fcd95a0a763356333528afa0013622665cc0ac5f94960e0f7231abe7c688bfa081bc82034e6fd8ed
-  data.tar.gz: 1406fdffcb6d44b7d7d0d0eab5fb2d970e501ff90336b88ed80962680021a845753463e14348203123ca612531248f1aab88ebbe0a3ec7cb30d8eb887e4b1ceb
+  metadata.gz: c2c84bb43ba856724e246d4fe264e739abe01d8abee3e8f39678893e671124b31a9e57748fe4347b5f3b1192e547c5bd76e8f84558f8a5035a12604e2635c0dd
+  data.tar.gz: dae9131834552ad7a23c16e36ead22ba1ef6b9f0e16e5747ab7cb9c29341120dddbd3cc2dd25969375898659ec3a93924f80c554afe382a659e9bf04ebab4208

data/lib/pg_conn/version.rb

@@ -1,3 +1,3 @@
 module PgConn
-  VERSION = "0.30.0"
+  VERSION = "0.31.0"
 end

data/lib/pg_conn.rb

@@ -32,6 +32,84 @@ module PgConn
     end
   end
 
+  # Quote argument as an identifier. The argument should be a non-nil string
+  # or a symbol
+  #
+  # Quote metods are both defined as PgConn class methods and as Connection
+  # member methods
+  #
+  def self.quote_identifier(s)
+    s = s.to_s if s.is_a?(Symbol)
+    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(", ")
+
+  # Quote the value as a string. Emit 'null' if value is nil
+  #
+  # 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'
+  #
+  # Note that a tuple value (an array) must be quoted using #quote_tuple
+  # because #quote_value would quote the tuple as an array instead of a list
+  # of values
+  #
+  # The :elem_type option can be a postgres type name (String or Symbol) or
+  # an array of type names. It is used as the required explicit element
+  # 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}[]"
+        else
+          "array[#{value.map { |elem| quote_value(elem) }.join(', ')}]"
+        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(", ")
+  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)
+    elem_types = Array(elem_types)
+    tuple.map { |value|
+      elem_type = value.is_a?(Array) ? elem_types&.shift : nil
+      quote_value(value, 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(", ")
+  end
+
   # Used to mark strings as literals that should not be quoted. This is the
   # case for row and record values
   class Literal < String; end
@@ -253,79 +331,13 @@ module PgConn
 
     def literal(arg) Literal.new(arg) end
 
-    # Quote argument as an identifier. The argument should be a non-nil string
-    # or a symbol
-    def quote_identifier(s)
-      s = s.to_s if s.is_a?(Symbol)
-      @pg_connection.escape_identifier(s).gsub(/\./, '"."').sub(/"\*"/, "*")
-    end
-
-    # Quote identifiers and concatenate them using ',' as separator
-    def quote_identifiers(idents) = idents.map { |ident| quote_identifier(ident) }.join(", ")
-
-    # Quote the value as a string. Emit 'null' if value is nil
-    #
-    # 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'
-    #
-    # Note that a tuple value (an array) must be quoted using #quote_tuple
-    # because #quote_value would quote the tuple as an array instead of a list
-    # of values
-    #
-    # The :elem_type option can be a postgres type name (String or Symbol) or
-    # an array of type names. It is used as the required explicit element
-    # 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 quote_value(value, elem_type: nil)
-      case value
-        when Literal; value
-        when String; @pg_connection.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}'"
-      else
-        @pg_connection.escape_literal(value.to_s)
-      end
-    end
-
-    # Quote values and concatenate them using ',' as separator
-    def quote_values(values, elem_type: nil)
-      values.map { |value| quote_value(value, elem_type: elem_type) }.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 quote_tuple(tuple, elem_types: nil)
-      elem_types = Array(elem_types)
-      tuple.map { |value|
-        elem_type = value.is_a?(Array) ? elem_types&.shift : nil
-        quote_value(value, elem_type: elem_type)
-      }.join(", ")
-    end
-
-    # Quote an array of tuples
-    def quote_tuples(tuples, elem_types: nil)
-      tuples.map { |tuple| "(#{quote_tuple(tuple, elem_types: elem_types)})" }.join(", ")
-    end
+    # Connection member method variations of the PgConn quote class methods
+    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)
 
     # 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
@@ -335,6 +347,9 @@ module PgConn
     # as fast as the other quote-methods. It is however very convenient when
     # you're testing and need a composite type because record-quoting can
     # easily become unwieldly
+    #
+    # 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)
     end
@@ -1123,5 +1138,17 @@ 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
+
 end
 

metadata

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