pg_conn 0.24.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45c913cadea7c545637f0291133fd43f727beef5efe726377c406e720c105d7d
-  data.tar.gz: 25ed1737f4bba574d02c7d1e1d823957de723f86e2eeca94f9ea8ef6160c191e
+  metadata.gz: 4148bbd8c21613249beed07d5248aa71780a8805881afc94899f9f29cd2d452d
+  data.tar.gz: 21bea1c8c108a4a135eb1d6936a56995b457db0e8192a17b745d0b3dd1676846
 SHA512:
-  metadata.gz: 696866896b4bea3ebec5313398f580581627535ccf7fca01f94f6f7e9a6198ceff7173b81d21d3725d4d7f0ac7118428a0eab2a098d3f360913926c46d460eaf
-  data.tar.gz: de5d2541d1384bfa7721f7ec3274f1a232b97d9bc08791f6f5a3c5783b19d5a8d65ac25d7d37cea0e47e27fc4391dad4eb0f15f96584875e0ed526d98bb1a520
+  metadata.gz: 7cca5aea976d949607b1650e8f00347a22be14907c8296a26379cd804a51f5610bb9786bc21b3b9317496a00ef135564033f276d5e3300dbd4d133b056835a79
+  data.tar.gz: 8bcf303b9712c1e6de69c301115c88a53d908aad90c8bce6b8e73e912d6b710772fb88a6bb191bc34142ca29f016845bfbc035cda4670c91d5e3d407ce82907e

data/TODO

@@ -1,4 +1,9 @@
 TODO
+  o Add a <fetch>! method
+      value? 0 or 1
+      value 1
+      values 0 or n
+      values! 1 or more
 
   o Instrumentation of connection object
 

data/lib/pg_conn/version.rb

@@ -1,3 +1,3 @@
 module PgConn
-  VERSION = "0.24.0"
+  VERSION = "0.26.0"
 end

data/lib/pg_conn.rb

@@ -269,8 +269,8 @@ module PgConn
     #
     # 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. The element types shoud be in
-    # the same order as the array arguments. Nested arrays is not supported
+    # 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
@@ -294,19 +294,62 @@ module PgConn
 
     # Quote values and concatenate them using ',' as separator
     def quote_values(values, elem_type: nil)
-      elem_types = Array(elem_type)
-      values.map { |value|
+      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 values as a tuple. Just an alias for #quote_values
-    def quote_tuple(tuple, elem_type: nil) = quote_values(tuple, elem_type: elem_type)
-
     # Quote an array of tuples
-    def quote_tuples(tuples, elem_type: nil)
-      tuples.map { |tuple| "(#{quote_values(tuple, elem_type: elem_type)})" }.join(", ")
+    def quote_tuples(tuples, elem_types: nil)
+      tuples.map { |tuple| "(#{quote_tuple(tuple, elem_types: elem_types)})" }.join(", ")
+    end
+
+    # Quote a record and cast it into the given type, the type can also be a
+    # table or view. 'data' is a hash or struct representation of the record
+    #
+    # Note that the fields are retrived from the database so this method is not
+    # 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
+    def quote_record(schema_name = nil, type, data, elem_types: nil)
+      qual_name = [schema_name, type].compact .join('.')
+
+      fields = self.values(%(
+        select attname
+        from pg_attribute
+        where
+          attrelid = '#{qual_name}'::regclass
+          and attnum > 0
+          and not attisdropped
+        order by attnum
+      )).map(&:to_sym)
+
+      values =
+          case data
+            when Hash; fields.map { |f| data[f] }
+            when OpenStruct; fields.map { |f| data.send(f) }
+            when Array; data
+          else
+            raise Error, "Illegal value #{data.inspect}"
+          end
+
+      "(#{quote_tuple(values, elem_types: elem_types)})::#{qual_name}"
+    end
+
+    def quote_records(schema_name = nil, type, datas, elem_types: nil)
+      qual_name = [schema_name, type].compact .join('.') + "[]"
+      records = datas.map { |data| quote_record(schema_name, type, data, elem_types: elem_types) }
+      "array[#{records.join(", ")}]::#{qual_name}"
     end
 
     # :call-seq:
@@ -630,7 +673,10 @@ module PgConn
     #
     # There is no variant that takes a single tuple because it would then be
     # impossible to have array or hash field values
-    def insert(*args)
+    def insert(*args, upsert: nil, **opts)
+      # Add options to args except the special :upsert option
+      args << opts if !opts.empty?
+
       # Add schema (=nil) if absent
       args.unshift nil if args.size == 2 || (args.size == 3 && args[1].is_a?(Array))
 
@@ -648,7 +694,7 @@ module PgConn
 
       # Find method and normalize data
       if data.is_a?(Array) # Array of tuples
-        method = :values
+        method = :values # The pg_conn method when multiple records are inserted
         if data.empty?
           return []
         elsif data.first.is_a?(Array) # Tuple (array) element. Requires the 'fields' argument
@@ -661,21 +707,37 @@ module PgConn
           raise ArgumentError
         end
       elsif data.is_a?(Hash)
-        method = :value
+        method = :value # The pg_conn method when only one record is inserted
         fields ||= data.keys
         tuples = [fields.map { |field| data[field] }]
       else
-        raise ArgumentError
+        raise ArgumentError, "Illegal argument '#{data.inspect}'"
       end
 
+      # On-conflict clause
+      upsert_sql =
+          case upsert
+            when true; "on conflict do nothing"
+            when String; "on conlict #{upsert}"
+            when false, nil; ""
+          else
+            raise ArgumentError, "Illegal value for :upsert option: #{upsert.inspect}"
+          end
+
       # Execute SQL statement using either :value or :values depending on data arity
       self.send method, %(
         insert into #{table} (#{quote_identifiers(fields)})
           values #{quote_tuples(tuples)}
+          #{upsert_sql}
           returning id
       )
     end
 
+    # Use upsert. Currently on 'on conflict do nothing' is supported
+    def upsert(*args)
+      insert(*args, upsert: true)
+    end
+
     # Update record(s)
     def update(schema = nil, table, expr, hash)
       table = [schema, table].compact.join(".")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_conn
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.26.0
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-07 00:00:00.000000000 Z
+date: 2024-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg