pg_conn 0.26.1 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dc75936f3c9bd5db772a2f8a80aa8e8bb25cbd1ae2181492766a7ed6ab9104a
-  data.tar.gz: 8ac094777a20c074f4a018b4bb0ea53efff219eb2401e18bf9c5887721fbb1fe
+  metadata.gz: 735772bb654f60ebbd736fb3cd13cb9af8dfe00a3b796d5447457adea435dddd
+  data.tar.gz: 6ee452ddb1a6e49d46b735b27d8a2f106959637d4e4373bf33d5ec72db757b9f
 SHA512:
-  metadata.gz: 8651be5de05b08d991cc257dab9cc060c4dfe22f8c22b2489f7e9ecc3654d51c55ad8494287b1cb829dc92a50cf60eb777b8814bcc23b348143caf9339729a8c
-  data.tar.gz: 8c11d1e8cb3ceb859438e9ccb98fe38de9ed9126c449c58972cef97d9fb3108c87ea2a18899aea9d500eaa249625d0a1a783176e3fd4e8bc7ebe035cec31f67b
+  metadata.gz: 4bf460966a99794fc05a134638acca681da79700ec1be145fcde276bcad2070c1a743fcf8ee8fde6c7d65a07d21026ef96b2cedb24e54b8fa61aa80ce59694ca
+  data.tar.gz: fa3e00167e8323f410def0d42c0e568f0185c90939e3891033a6a7e55dcdd5a0b0f50a5343f95c5f3ca2b0bba22312fd65fef25bc323f26956dfca3b9f45844a

data/lib/pg_conn/session_methods.rb

@@ -16,14 +16,14 @@ module PgConn
       else
         conn.tuples %(
           select datname, usename
-          from pg_stat_activity 
+          from pg_stat_activity
           where datname is not null and usename is not null
         )
       end
     end
 
     # Return true if the given database accepts connections
-    def enabled?(database) 
+    def enabled?(database)
       !database.nil? or raise ArgumentError
       conn.value "select datallowconn from pg_catalog.pg_database where datname = '#{database}'"
     end
@@ -50,19 +50,21 @@ module PgConn
     #       multiple sessions (is this ever relevant?)
     #
     def terminate(database, *users)
+      users = Array(users).flatten
       !database.nil? or raise ArgumentError
       enabled = self.enabled?(database)
 
       case users
-        when []; 
+        when [];
           return
         when [nil]
           self.disable(database) if enabled
           users = self.list(database)
-        else 
+        else
           users = Array(users).flatten
       end
       pids = self.pids(database, users)
+
       if !pids.empty?
         pids_sql = pids.map { |pid| "(#{pid})" }.join(", ")
         conn.execute "select pg_terminate_backend(pid) from ( values #{pids_sql} ) as x(pid)"
@@ -71,7 +73,7 @@ module PgConn
     end
 
     # Run block without any connected users. Existing sessions are terminated
-    def exclusive(database, &block) 
+    def exclusive(database, &block)
       !database.nil? or raise ArgumentError
       begin
         disable(database)
@@ -85,7 +87,7 @@ module PgConn
     # Return true if session triggers are enabled. Triggers are enabled by
     # default by Postgres
     def triggers?() conn.value "select current_setting('session_replication_role') <> 'replica'" end
-    
+
     # Enable session triggers
     def enable_triggers()
       conn.execute "set session session_replication_role = DEFAULT"

data/lib/pg_conn/version.rb

@@ -1,3 +1,3 @@
 module PgConn
-  VERSION = "0.26.1"
+  VERSION = "0.27.0"
 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,35 @@ module PgConn
       end
     end
 
+    # :call-seq
+    #   parse_query(query)
+    #   parse_query(table, id_or_where_clause = "true", 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 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.1
+  version: 0.27.0
 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