pg_conn 0.30.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28c2a6429f9c8e987f27686e323643baf77f4429599bfb457ecdd6d5b659a289
-  data.tar.gz: e8e2c96d92401a3eceff86b77152acdfe9019c03306577d260c6039d39881630
+  metadata.gz: e4afbef1cc74d235f8434c2c92a6537ec24b37cd36e85bb9f07eb6153e6c7938
+  data.tar.gz: cd5af7434cb01ae1f873a7cb18a4cc350e425976c695b93252f2e36cefca2273
 SHA512:
-  metadata.gz: b6f08ca6bd0b47206623435dbf6691f0d8276fa5a8ac1c71fcd95a0a763356333528afa0013622665cc0ac5f94960e0f7231abe7c688bfa081bc82034e6fd8ed
-  data.tar.gz: 1406fdffcb6d44b7d7d0d0eab5fb2d970e501ff90336b88ed80962680021a845753463e14348203123ca612531248f1aab88ebbe0a3ec7cb30d8eb887e4b1ceb
+  metadata.gz: c94d25247ae2167f022a704bdf5b03691f87691dfe88c5187a5cbf2fb117c5ac252c3f649b5b0a20578cfe325b08cfff7f09e41da1d8f6c0bbf81c11cab501bf
+  data.tar.gz: 689be40d28cb3a7ea0c84ab0109b7dc7749b16c47a8240b694ae746ff8602ebed6e5fa4394dc628d1df699a6c7c091db7f345c1ffb81cfc93e81e98d48c60ea0

data/lib/pg_conn/version.rb

@@ -1,3 +1,3 @@
 module PgConn
-  VERSION = "0.30.0"
+  VERSION = "0.32.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
@@ -943,6 +958,40 @@ module PgConn
       end
     end
 
+    def dump(*query)
+      records = self.records(*query)
+
+      if records.empty?
+        puts "No records found"
+      else
+        headers = records.first.keys
+        column_widths = headers.map(&:size)
+        column_signs = [nil] * headers.size
+
+        records.each { |r|
+          r.values.each.with_index { |v, i|
+            value_width = v.to_s.size
+            column_widths[i] = [column_widths[i], value_width].max
+
+            column_signs[i] ||=
+              case v
+                when nil; nil
+                when Integer; ""
+              else
+                "-"
+              end
+          }
+        }
+
+        header_format = column_widths.map { |w,t| "%-#{w}s" }.join(" ")
+        body_format = column_widths.zip(column_signs).map { |w,s| "%#{s}#{w}s" }.join(" ")
+
+        printf "#{header_format}\n", *headers
+        printf "#{header_format}\n", *column_widths.map { |w| "-" * w }
+        records.each { |r| printf "#{body_format}\n", *r.values }
+      end
+    end
+
   private
     # Wrapper around PG::Connection.new that switches to the postgres user
     # before connecting if the current user is the root user
@@ -1123,5 +1172,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.32.0
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-11 00:00:00.000000000 Z
+date: 2025-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg