pg_conn 0.26.2 → 0.27.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 419e3bd17f4343be6860d172864ad0eeaaed032ab72cc659a02afa14914cdf65
-  data.tar.gz: 00d673f75424491bd322cf1321cc8afbb67eba1d955a9545b4f7a0df334bc0b8
+  metadata.gz: 01735ada71fba436bf8387651722d380b68bfa9c028666946d343e22f94fb1ea
+  data.tar.gz: de757bfe82276b1641c693f93afcc630bcdea37d1bb33d65888652fdce6f3656
 SHA512:
-  metadata.gz: 9e732a7523af59a16052603766aeea731d3d54a4f36fbd250f2dea33b85d1bc890af2fb7de4f8efb96d816eed2ecce390fb4510224715f78bd75a693c4243062
-  data.tar.gz: f1b0b073a7231a68a5e0e3b255523c50000db9d50e24596a7545d9228b84bc69056a70b4c8111f899ad6852990ac6b84dc646f2e369c7cb4fbe77f77615d65e7
+  metadata.gz: d15f076992d6bf1eaa05b5ba8b7f3a3cc7ca4150543449717ecf1a94f16d08d71602e55384dedb13fba4ab06465a8dc1ae1e109ef698cf848d0264243d49e1c5
+  data.tar.gz: 69b9a3cbd175d20e4b806a18124a008eff5ef33bdcfd4d3b482d50cbba20ce95f9684a407b1122cd7dee2464b96496b2803d22c93b2c6190ba52332248a8de4d

data/lib/pg_conn/version.rb

@@ -1,3 +1,3 @@
 module PgConn
-  VERSION = "0.26.2"
+  VERSION = "0.27.1"
 end

data/lib/pg_conn.rb

@@ -250,7 +250,7 @@ module PgConn
     # or a symbol
     def quote_identifier(s)
       s = s.to_s if s.is_a?(Symbol)
-      @pg_connection.escape_identifier(s)
+      @pg_connection.escape_identifier(s).gsub(/\./, '"."').sub(/"\*"/, "*")
     end
 
     # Quote identifiers and concatenate them using ',' as separator
@@ -339,15 +339,8 @@ module PgConn
     #
     # Return true iff the query returns exactly one record. Use '!empty?' to
     # check if the query returns one or more records
-    def exist?(*args)
-      arg1, arg2 = *args
-      query =
-          case arg2
-            when Integer; "select from #{arg1} where id = #{arg2}"
-            when String; "select from #{arg1} where #{arg2}"
-            when NilClass; arg1
-          end
-      count(query) == 1
+    def exist?(*query)
+      !empty?(*query)
     end
 
     # :call-seq:
@@ -355,14 +348,9 @@ module PgConn
     #   count(table, where_clause = nil)
     #
     # Return true if the table or the result of the query is empty
-    def empty?(arg, where_clause = nil)
-      if arg =~ /\s/
-        value "select count(*) from (#{arg} limit 1) as inner_query"
-      elsif where_clause
-        value "select count(*) from (select 1 from #{arg} where #{where_clause} limit 1) as inner_query"
-      else
-        value "select count(*) from (select 1 from #{arg} limit 1) as inner_query"
-      end == 0
+    def empty?(*query)
+      inner_query = parse_query *query
+      self.value("select count(*) from (#{inner_query} limit 1) as \"inner_query\"") == 0
     end
 
     # :call-seq:
@@ -370,27 +358,20 @@ module PgConn
     #   count(table_name, where_clause = nil)
     #
     # The number of records in the table or in the query
-    def count(arg, where_clause = nil)
-      if arg =~ /\s/
-        value("select count(*) from (#{arg}) as inner_query")
-      else
-        value("select count(*) from #{arg}" + (where_clause ? " where #{where_clause}" : ""))
-      end
+    def count(*query)
+      inner_query = parse_query *query
+      value("select count(*) from (#{inner_query}) as inner_query")
     end
 
-    # TODO
-    #   Query variants
-    #     (sql) - simple SQL statement
-    #     (schema = nil, table, id-or-where-clause = nil, field-or-fields)
-    #
-
     # 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 also be used to execute 'insert'
-    # statements with a 'returning' clause
-    def value(query) #, transaction: false, commit: true)
-      r = pg_exec(query)
+    # single record with a single column.
+    #
+    # TODO 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 also be used to execute 'insert' statements with a
+    # 'returning' clause
+    def value(*query) #, transaction: false, commit: true)
+      r = pg_exec(parse_query *query)
       check_1c(r)
       check_1r(r)
       r.values[0][0]
@@ -398,8 +379,8 @@ module PgConn
 
     # Like #value but returns nil if no record was found. It is still an error
     # if the query returns more than one column
-    def value?(query) #, transaction: false, commit: true)
-      r = pg_exec(query)
+    def value?(*query) #, transaction: false, commit: true)
+      r = pg_exec(parse_query *query)
       check_1c(r)
       return nil if r.ntuples == 0
       check_1r(r)
@@ -407,28 +388,32 @@ module PgConn
     end
 
     # Return an array of values. It is an error if the query returns records
-    # with more than one column. If :transaction is true, the query will be
-    # executed in a transaction and be committed it :commit is true (the
-    # default). This can be used in 'insert ... returning ...' statements
-    def values(query)
-      r = pg_exec(query)
+    # with more than one column.
+    #
+    # TODO If :transaction is true, the query will be executed in a
+    # transaction and be committed it :commit is true (the default). This can
+    # be used in 'insert ... returning ...' statements
+    def values(*query)
+      r = pg_exec(parse_query *query)
       check_1c(r)
       r.column_values(0)
     end
 
     # Return an array of column values. It is an error if the query returns
-    # more than one record. If :transaction is true, the query will be executed
+    # more than one record.
+    #
+    # TODO If :transaction is true, the query will be executed
     # in a transaction and be committed it :commit is true (the default). This
     # can be used in 'insert ... returning ...' statements
-    def tuple(query)
-      r = pg_exec(query)
+    def tuple(*query)
+      r = pg_exec(parse_query *query)
       check_1r(r)
       r.values[0]
     end
 
     # Like #tuple but returns nil if no record was found
-    def tuple?(query)
-      r = pg_exec(query)
+    def tuple?(*query)
+      r = pg_exec(parse_query *query)
       return nil if r.ntuples == 0
       check_1r(r)
       r.values[0]
@@ -437,24 +422,24 @@ module PgConn
     # Return an array of tuples. If :transaction is true, the query will be
     # executed in a transaction and be committed it :commit is true (the
     # default). This can be used in 'insert ... returning ...' statements
-    def tuples(query)
-      pg_exec(query).values
+    def tuples(*query)
+      pg_exec(parse_query *query).values
     end
 
     # Return a single-element hash from column name to value. It is an error
     # if the query returns more than one record or more than one column. Note
-    # that you will probably prefer to use #value instead when you expect only
-    # a single field
-    def field(query)
-      r = pg_exec(query)
+    # that you will probably prefer to use #value instead when you query a
+    # single field
+    def field(*query)
+      r = pg_exec(parse_query *query)
       check_1c(r)
       check_1r(r)
       r.tuple(0).to_h
     end
 
     # Like #field but returns nil if no record was found
-    def field?(query)
-      r = pg_exec(query)
+    def field?(*query)
+      r = pg_exec(parse_query *query)
       check_1c(r)
       return nil if r.ntuples == 0
       check_1r(r)
@@ -465,8 +450,8 @@ module PgConn
     # is an error if the query returns records with more than one column. Note
     # that you will probably prefer to use #values instead when you expect only
     # single-column records
-    def fields(query)
-      r = pg_exec(query)
+    def fields(*query)
+      r = pg_exec(parse_query *query)
       check_1c(r)
       r.each.to_a.map(&:to_h)
     end
@@ -474,43 +459,43 @@ module PgConn
     # Return a hash from column name (a Symbol) to field value. It is an error if
     # the query returns more than one record. It blows up if a column name is
     # not a valid ruby symbol
-    def record(query)
-      r = pg_exec(query)
+    def record(*query)
+      r = pg_exec(parse_query *query)
       check_1r(r)
       r.tuple(0).to_h
     end
 
     # Like #record but returns nil if no record was found
-    def record?(query)
-      r = pg_exec(query)
+    def record?(*query)
+      r = pg_exec(parse_query *query)
       return nil if r.ntuples == 0
       check_1r(r)
       r.tuple(0).to_h
     end
 
     # Return an array of hashes from column name to field value
-    def records(query)
-      r = pg_exec(query)
+    def records(*query)
+      r = pg_exec(parse_query *query)
       r.each.to_a.map(&:to_h)
     end
 
     # Return a record as a OpenStruct object. It is an error if the query
     # returns more than one record. It blows up if a column name is not a valid
     # ruby symbol
-    def struct(query)
-      OpenStruct.new(**record(query))
+    def struct(*query)
+      OpenStruct.new(**record(parse_query *query))
     end
 
     # Like #struct but returns nil if no record was found
-    def struct?(query)
-      args = record?(query)
+    def struct?(*query)
+      args = record?(parse_query *query)
       return nil if args.nil?
       OpenStruct.new(**args)
     end
 
     # Return an array of OpenStruct objects
-    def structs(query)
-      records(query).map { |record| OpenStruct.new(**record) }
+    def structs(*query)
+      records(parse_query *query).map { |record| OpenStruct.new(**record) }
     end
 
     # Return a hash from the record id column to record (hash from column name
@@ -996,6 +981,42 @@ module PgConn
       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...)
+    #
+    # Parse a query. Used in query-functions (#value etc.). The fields argument
+    # can be a list of fields or arrays of fields
+    #
+    def parse_query(*args)
+      args.size > 0 or raise ArgumentError
+      return args.first if args.size == 1 && args.first =~ / /
+
+      table = args.shift
+      where_clause = "true"
+      fields = []
+      case args.first
+        when Integer; where_clause = "id = #{args.shift}"
+        when String; where_clause = args.shift
+        when Hash
+          where_clause = args.shift.map { |k,v|
+            "#{self.quote_identifier(k)} = #{self.quote_value(v) }"
+          }.join(" and ")
+        when Symbol; fields << args.shift
+        when Array; fields = args.shift
+        when nil; where_clause = "true"
+      else
+        raise ArgumentError
+      end
+      fields.concat args.flatten
+      field_list = fields.empty? ? "*" : self.quote_identifiers(fields)
+
+      "select #{field_list} from #{table} where #{where_clause}"
+    end
+
     # :call-seq:
     #   pg_exec(string)
     #   pg_exec(array)

metadata

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