pg_conn 0.17.3 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef63ee68c793ec597f74abe4f85815b489199f5f71db4e92f583e3a7789b58ef
-  data.tar.gz: 073d54f4b5000882ce86b6b09ae92b4fa8d2230015198ad07f54d0b6ed465c03
+  metadata.gz: 91bfceabfdba86eba789108cea2718e382fe6849b580ef3be3a428a8f08ab45e
+  data.tar.gz: 0014ae1ccc9c6cf95f63fce78d5a094b7068e711ed18d0edcdaafe35d47ef04b
 SHA512:
-  metadata.gz: 52d717e25fbbe755c2bceaa77c1da02bfbe82dabc30f0ce22673f1791b9fbfe50cc0f6539221c766db526d42f224baeb1da22f29cba861ada5ea8334413b2899
-  data.tar.gz: 54fe0f036e61099b2fd5807da67e1528930ce79386a91f570eb11ba9d6eac5d5c63a89e4c2702b5304a9680cecf904577860ef9fa251a4485d344fea31b61cdd
+  metadata.gz: 6302b2051fd7a152b026ed7a412ad9025ae7fbdb6f260173c5731c123f367c7535a9522e2654ccc09950d14c9e3009c1daf6d52fa7fc3114c3b9f196e6db0570
+  data.tar.gz: c793534b923e08cc22121dc824c858003cb495e2453cb77cd7007672e242a62ff8819ab966f2f9d70a552f3a080da2627c1ec1211990eefcbe87bdcc1a5c06e8

data/TODO

@@ -1,6 +1,28 @@
 TODO
-  o Create aliases
+  o db.context(schema: app_portal, transaction: true) { ... }
+    db.context(set: app_portal, transaction: true) { ... }
+    db.context(add: app_portal, transaction: true) { ... }
+
+  o In the doc; compare a VisualBasic call to a function with PgConn's:
+
+			Set cmd = Server.CreateObject("ADODB.Command")
+			cmd.CommandText = "sp_nic_update_comtext"
+			cmd.CommandType = adCmdStoredProc
+			cmd.Parameters.Append cmd.CreateParameter("Id", adGUID, adParamInput, ,strId)
+			cmd.Parameters.Append cmd.CreateParameter("comtext", adVarWChar, adParamInput,2048 ,strComtext)
+			cmd.Parameters.Append cmd.CreateParameter("UserId", adGUID, adParamInput, , Site.CurrentUser.Id.ToString())
+			cnn.ExecuteCommandNonQuery cmd
+
+    vs
+
+      server.call :sp_nic_update_comtext, str_id, str_comtext, site.current_user.id
 
+
+  o Have a 'with' method that combines multiple brachet-methods:
+
+      conn.with(schema: public, transation: true) { ... }
+
+  o Create aliases
       tuple   ->  array
       tuples      arrays
       field

data/lib/pg_conn/version.rb

@@ -1,3 +1,3 @@
 module PgConn
-  VERSION = "0.17.3"
+  VERSION = "0.19.0"
 end

data/lib/pg_conn.rb

@@ -327,8 +327,8 @@ module PgConn
     # Return a single value. It is an error if the query doesn't return a
     # single record with a single column. If :transaction is true, the query
     # will be executed in a transaction and also be committed if :commit is
-    # true (this is the default). It can be used to execute 'insert' statements
-    # with a 'returning' clause
+    # true (this is the default). It can also be used to execute 'insert'
+    # statements with a 'returning' clause
     def value(query) #, transaction: false, commit: true)
       r = pg_exec(query)
       check_1c(r)
@@ -507,7 +507,7 @@ module PgConn
     # Returns a hash from the first field to a tuple of the remaining fields.
     # If there is only one remaining field then that value is used instead of a
     # tuple of that value. The optional +key+ argument sets the mapping field
-    def map(query, key = nil)
+    def map(query, key = nil) # TODO Swap arguments
       r = pg_exec(query)
       begin
         key = (key || r.fname(0)).to_s
@@ -525,6 +525,23 @@ module PgConn
       h
     end
 
+    def multimap(query, key = nil)
+      r = pg_exec(query)
+      begin
+        key = (key || r.fname(0)).to_s
+        key_index = r.fnumber(key.to_s)
+        one = (r.nfields == 2)
+      rescue ArgumentError
+        raise Error, "Can't find column #{key}"
+      end
+      h = {}
+      r.each_row { |row|
+        key_value = row.delete_at(key_index)
+        (h[key_value] ||= []) << (one ? row.first : row)
+      }
+      h
+    end
+
     # Return the value of calling the given function (which can be a String or
     # a Symbol and can contain the schema of the function). It dynamically
     # detects the structure of the result and return a value or an array of
@@ -567,16 +584,59 @@ module PgConn
       end
     end
 
-    # Insert record(s) in a table. Returns the id of the inserted record(s)
-    def insert(schema = nil, table, array_or_hash)
-      return [] if array_or_hash.empty?
-      table = [schema, table].compact.join(".")
-      is_array = array_or_hash.is_a?(Array)
-      array = is_array ? array_or_hash : [array_or_hash]
-      identifiers = quote_identifier_list(array.first.keys)
-      literals = array.map { |hash| quote_literal_list(hash.values) }.join(", ")
-      method = (is_array ? :values : :value)
-      self.send method, %(insert into #{table} #{identifiers} values #{literals} returning id)
+    # :call-seq*
+    #   insert(table, record|records)
+    #   insert(table, fields, record|records|tuples)
+    #   insert(schema, table, record|records)
+    #   insert(schema, table, fields, record|records|tuples)
+    #
+    # Insert record(s) in table and return id(s)
+    #
+    # 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)
+      # Add schema (=nil) if absent
+      args.unshift nil if args.size == 2 || (args.size == 3 && args[1].is_a?(Array))
+
+      # Add fields (=nil) if absent
+      args.insert(-2, nil) if !args[-2].is_a?(Array)
+
+      # Check number of arguments
+      args.size == 4 or raise ArgumentError, "Illegal number of arguments"
+
+      # Extract parameters
+      schema, table, fields, data = args
+
+      # Normalize table
+      table = schema ? "#{schema}.#{table}" : table
+
+      # Find method and normalize data
+      if data.is_a?(Array) 
+        if data.empty?
+          return []
+        elsif data.first.is_a?(Array)
+          method = :values
+          fields or raise ArgumentError
+          tuples = data
+        elsif data.first.is_a?(Hash)
+          method = :values
+          fields ||= data.first.keys
+          tuples = data.map { |record| fields.map { |field| record[field] } }
+        else
+          raise ArgumentError
+        end
+      elsif data.is_a?(Hash)
+        method = :value
+        fields ||= data.keys
+        tuples = [fields.map { |field| data[field] }]
+      else
+        raise ArgumentError
+      end
+
+      # Build and execute SQL statement
+      columns = quote_identifier_list(fields)
+      values = tuples.map { |tuple| quote_literal_list(tuple) }.join(', ')
+      self.send method, %(insert into #{table} #{columns} values #{values} returning id)
     end
 
     # Update record(s)

metadata

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