pg_conn 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: df5aa73c1d8e34263b51b29acb63f2d675e7945141e44d9f5adbd00987d1bb46
+  data.tar.gz: 56ad22f1c45fb8e78d43f59ff4b982da09d86d4e1fdfd802cf7e396d66a16ece
+SHA512:
+  metadata.gz: b94e9e6b1ed7605aceab03fb0393e79f5f57ef1e7bb26794cd8b25a8de93c7f4358686dc910a2d76132941daa7c2ce113d20c45144ff9e2ff6fb3e5a744f96b6
+  data.tar.gz: 386d086a0af25b2f049046a083e1af1f947a7fbed63b0a5787659fe95414678761d93fcddb4ddce04b7a97d1dcb82160c7ff6bf79ec4aabe1d18ec49f55d62b9

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.7.1

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in pg_conn.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/README.md

@@ -0,0 +1,35 @@
+# PgConn
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/pg_conn`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pg_conn'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install pg_conn
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/pg_conn.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/TODO

@@ -0,0 +1,70 @@
+TODO
+  o fix silent
+  o fix fail
+  o A PgConn.new with a block. Useful for temporary database connections (a
+    rather specialized use-case, though)
+  o A "#bag" method that allows duplicate IDs
+  o Generalize #set using :element_type option. This makes #table a special case of #set
+  o Maybe grant/revoke methods. Problem that there is large number of variations
+      # :callseq:
+      #   grant(role, to_role)
+      #   grant(privilege, subject, to_role)
+      def grant(role, to_role)
+        # 
+        conn.exec "grant #{role} to #{to_role}"
+      end
+  o Allow a :type argument to all query methods that can be used to specify the
+    composition of anonymous record types
+
+
+REFACTOR
+  #!/usr/bin/env ruby
+
+  module PgConn
+    # Global PgConn instance
+    def self.instance() @@pg_conn_instance ||= PgConn.new end
+    def self.instance=(pg_conn) @@pg_conn_instance = pg_conn end
+
+    def self.connect(*args)
+      conn = PgConn.new(*args)
+      @@pg_conn_instance ||= conn
+      conn
+    end
+
+    def self.new() raise "TODO" end
+
+    class PgConn
+      include PgQuery
+      include PgTransaction
+      attr_reader :schema
+      attr_reader :role
+      attr_reader :rdbms
+    end
+
+    class Connection
+      attr_reader :query
+      attr_reader :transaction
+      attr_reader :schema
+      attr_reader :role
+      attr_reader :rdbms
+    end
+  end
+
+  module SchemaMethods
+    def conn() "schema_methods_conn" end
+    def schema_doit() puts "#{conn}: schema_doit" end
+  end
+
+  class SchemaMethodsObject
+    include SchemaMethods
+    def conn() "schema_methods_object_conn" end
+    def doit() schema_doit end
+  end
+
+  s = SchemaMethodsObject.new
+  s.doit
+  s.schema_doit
+
+  # Example
+  include PgConn
+  p values "select * from t" # Connection is set up by default

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "pg_conn"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/pg_conn/rdbms_methods.rb

@@ -0,0 +1,136 @@
+
+module PgConn
+  class Error < StandardError; end # Move to exception.rb
+  class PsqlError < Error; end
+
+  class RdbmsMethods
+    attr_reader :conn
+
+    def initialize(conn)
+      @conn = conn
+      # TODO: Check if conn is a superuser connection
+    end
+
+    # Return true if the database exists
+    def exist?(database)
+      conn.exist? %(
+          select 1
+          from pg_database
+          where datname = '#{database}'
+      )
+    end
+
+    # Create a new database
+    def create(database, owner: ENV['USER'], template: "template1") 
+      owner_clause = owner ? "owner = \"#{owner}\"" : nil
+      template_clause = template ? "template = \"#{template}\"" : nil
+      stmt = ["create database \"#{database}\"", owner_clause, template_clause].compact.join(" ")
+      conn.execute stmt # Note we're using #execute instead of #exec because
+                        # create database can't run within a transaction
+    end
+
+    # Drop a database
+    def drop(database)
+      conn.execute "drop database if exists \"#{database}\""
+      true
+    end
+
+    # List databases in the RDBMS
+    def list(all: false, exclude: [])
+      exclude += POSTGRES_DATABASES if !all
+      exclude_sql_list = "'" + exclude.join("', '") + "'"
+      exclude_clause = exclude.empty? ? nil : "where datname not in (#{exclude_sql_list})"
+      stmt = ["select datname from pg_database", exclude_clause].compact.join(" ")
+      conn.values stmt
+    end
+
+    # Return the owner of the database
+    def owner(database)
+      conn.value %(
+        select r.rolname
+        from (values ('#{database}')) as v (database)
+        left join pg_database d on d.datname = v.database
+        left join pg_roles r on r.oid = d.datdba
+      )
+    end
+
+    # Return list of users currently logged in to the database or to any
+    # database if database is nil
+    #
+    # FIXME: There is a possible race-condition here where some process
+    # (auto-vacuum) is logged in to the database but has a nil username. The
+    # easy fix is to have usename not null but it would be nice to know what
+    # exactly is triggering this problem
+    #
+    def users(database)
+      database_clause = database ? "datname = '#{database}'" : nil
+      query = ["select usename from pg_stat_activity", database_clause].compact.join(" where ")
+      conn.values query
+    end
+
+    # Hollow-out a database by removing all schemas in the database. The public
+    # schema is recreated afterwards. Use the current database if @database is
+    # nil
+    #
+    # Note that the database can have active users logged in while the database
+    # is emptied
+    #
+    def empty!(database = nil, exclude: [])
+      local = !database.nil?
+      begin
+        conn = local ? PgConn.new(database) : self.conn
+        schemas = 
+            conn
+              .values("select nspname from pg_namespace where nspowner != 10 or nspname = 'public'")
+              .select { |schema| !exclude.include?(schema) }
+              .join(", ")
+        conn.exec %(
+            drop schema #{schemas} cascade;
+            create schema public authorization postgres;
+            grant usage, create on schema public to public
+        )
+      ensure
+        conn&.terminate if local
+      end
+    end
+
+    # Fast copy using templates. Note that no user may be logged in to the
+    # source database for this to work
+    def copy(from_database, to_database, owner: ENV['USER'])
+      create(to_database, owner: owner, template: from_database)
+    end
+
+    def load(database, file, role: ENV['USER'], gzip: nil)
+      command_opt = role ? "-c \"set role #{role}\";\n" : nil
+      if gzip
+        pipe_cmd = file ? "gunzip --to-stdout #{file} |" : "gunzip --to-stdout |"
+        file_opt = nil
+      else
+        pipe_cmd = nil
+        file_opt = file ? "-f #{file}" : nil
+      end
+      cmd = [pipe_cmd, "psql -v ON_ERROR_STOP=1", command_opt, file_opt, database].compact.join(" ")
+      stdout, stderr, status = Open3.capture3(cmd)
+      status == 0 or raise PsqlError.new(stderr)
+    end
+
+    def save(database, file, data: true, schema: true, gzip: nil)
+      data_opt = data ? nil : "--schema-only"
+      schema_opt = schema ? nil : "--data-only"
+      if gzip
+        pipe_cmd = file ? "| gzip >#{file}" : "| gzip"
+        file_opt = nil
+      else
+        pipe_cmd = nil
+        file_opt = file ? "-f #{file}" : nil
+      end
+      cmd = ["pg_dump --no-owner", data_opt, schema_opt, file_opt, database, pipe_cmd].compact.join(" ")
+      stdout, stderr, status = Open3.capture3(cmd)
+      status == 0 or raise PsqlError.new(stderr)
+    end
+
+  private
+    POSTGRES_DATABASES = %w(template0 template1 postgres)
+  end
+end
+

data/lib/pg_conn/role_methods.rb

@@ -0,0 +1,96 @@
+module PgConn
+  class RoleMethods
+    attr_reader :conn
+
+    def initialize(conn)
+      @conn = conn
+      # TODO: Check if conn is a superuser connection
+    end
+
+    # Return true if role(s) exists
+    def exist?(*rolenames, superuser: nil, can_login: nil)
+      rolenames = Array(rolenames).flatten.compact
+      rolename_clause = "rolname in (#{PgConn.sql_values(rolenames)})"
+      superuser_clause =
+          case superuser
+            when true; "rolsuper"
+            when false; "not rolsuper"
+          else
+            nil
+          end
+      can_login_clause = 
+          case can_login
+            when true; "rolcanlogin"
+            when false; "not rolcanlogin"
+          else
+            nil
+          end
+      where_clause = [rolename_clause, superuser_clause, can_login_clause].compact.join(" and ")
+      conn.value("select count(*) from pg_roles where #{where_clause}") == rolenames.size
+    end
+
+    # Return true if the user can login
+    def can_login?(username, superuser: nil)
+      exist?(username, superuser: superuser, can_login: true)
+    end
+
+    alias_method :user?, :can_login?
+
+    # Return true if the user is a superuser
+    def superuser?(username)
+      exist?(username, superuser: true)
+    end
+
+    # Create a new role
+    def create(rolename, superuser: false, create_database: false, can_login: false, create_role: false)
+      user_decl = "create role \"#{rolename}\""
+      superuser_decl = superuser ? "--superuser" : nil
+      create_database_decl = create_database ? "--createdb" : "--nocreatedb"
+      can_login_decl = can_login ? "--login" : "--nologin"
+      create_role_decl = create_role ? "--createrole" : "--nocreaterole"
+
+      stmt = [user_decl, superuser_decl, can_login_decl, create_role_decl].compact.join(" ")
+      conn.exec stmt
+    end
+
+    # Remove all privileges from the given role
+    def clean(rolename)
+    end
+
+    # Drop existing users. Return true if any role was dropped. Drop depending
+    # privileges and objects too if :cascade is true. Note that cascade only
+    # works if connected to the database where the privileges exist. The
+    # :silent option is used in tests - fix it somehow!
+    def drop(*rolenames, cascade: false, silent: false)
+      rolenames = Array(rolenames).flatten.compact.select { |role| exist?(role) }
+      return false if rolenames.empty?
+      rolenames_sql = PgConn.sql_idents(rolenames)
+      conn.exec "drop owned by #{rolenames_sql} cascade" if cascade
+      conn.exec "drop role #{rolenames_sql}"
+      true
+    end
+
+    # List users. TODO Use RE instead of database argument. Also doc this shit
+    # FIXME: Depends on the <database>__<username> convention
+    def list(database: nil, owner: false, superuser: nil, can_login: nil)
+      database_clause = database && "rolname like '#{database}__%'"
+      database_clause = database && "(#{database_clause} or rolname = '#{database}')" if owner
+      superuser_clause = superuser.nil? ? nil : "rolsuper = #{superuser}"
+      can_login_clause = can_login.nil? ? nil : "rolcanlogin = #{can_login}"
+      query = [
+          "select rolname from pg_roles where true", 
+          database_clause, superuser_clause, can_login_clause
+      ].compact.join(" and ")
+      conn.values(query)
+    end
+  end
+end
+
+
+
+
+
+
+
+
+

data/lib/pg_conn/schema_methods.rb

@@ -0,0 +1,157 @@
+
+module PgConn
+  # Schema methods
+  class SchemaMethods
+    attr_reader :conn
+
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # Return true if schema exists
+    def exist?(schema)
+      conn.exist? %(
+          select 1
+          from information_schema.schemata
+          where schema_name = '#{schema}'
+      )
+    end
+
+    # Create a new schema. The authorization option can be used to set the
+    # owner of the schema
+    def create(schema, authorization: nil)
+      authorization_clause = authorization ? "authorization #{authorization}" : nil
+      stmt = ["create schema", schema, authorization_clause].compact.join(" ")
+      conn.exec stmt
+    end
+
+    # Drop schema
+    def drop(schema, cascade: false)
+      if cascade
+        conn.exec "drop schema if exists #{schema} cascade"
+      else
+        conn.exec "drop schema if exists #{schema}"
+      end
+      true
+    end
+
+    # List schemas. By built-in schemas are not listed unless the :all option
+    # is true. The :exclude option can be used to exclude named schemas
+    def list(all: false, exclude: [])
+      conn.values(%(
+          select schema_name
+          from information_schema.schemata
+      )).select { |schema|
+        !exclude.include?(schema) && (all ? true : schema !~ /^pg_/ && schema != "information_schema")
+      }
+    end
+
+    # Returns true if relation (table or view) exists
+    def exist_relation?(schema, relation)
+      conn.exist? relation_exist_query(schema, relation)
+    end
+
+    # Return true if table exists
+    def exist_table?(schema, table)
+      conn.exist?(relation_exist_query(schema, table, kind: %w(r)))
+    end
+
+    # Return true if view exists
+    def exist_view?(schema, view)
+      conn.exist? relation_exist_query(schema, view, kind: %w(v m))
+    end
+
+    # Return true if the column exists
+    def exist_column?(schema, relation, column)
+      conn.exist? column_exist_query(schema, relation, column)
+    end
+
+    # Return list of relations in the schema
+    def list_relations(schema)
+      conn.values relation_list_query(schema)
+    end
+
+    # Return list of tables in the schema
+    def list_tables(schema)
+      conn.values relation_list_query(schema, kind: %w(r))
+    end
+
+    # Return list of view in the schema
+    def list_views(schema)
+      conn.values relation_list_query(schema, kind: %w(v m))
+    end
+
+    # Return a list of columns. If relation is defined, only columns from that
+    # relation are listed. Columns are returned as fully qualified names (eg.
+    # "schema.relation.column")
+    def list_columns(schema, relation = nil)
+      conn.values column_list_query(schema, relation)
+    end
+
+    def exist_function(schema, function, signature)
+      raise NotImplementedError
+    end
+
+    def list_functions(schema, function = nil)
+      raise NotImplementedError
+    end
+
+  private
+    def relation_exist_query(schema, relation, kind: nil)
+      kind_sql_list = "'" + (kind.nil? ? %w(r v m) : Array(kind).flatten).join("', '") + "'"
+      %(
+          select  1
+          from    pg_class 
+          where   relnamespace::regnamespace::text = '#{schema}'
+          and     relname = '#{relation}'
+          and     relkind in (#{kind_sql_list})
+      )
+    end
+
+    def relation_list_query(schema, kind: nil)
+      kind_sql_list = "'" + (kind.nil? ? %w(r v m) : Array(kind).flatten).join("', '") + "'"
+      %(
+          select  relname
+          from    pg_class 
+          where   relnamespace::regnamespace::text = '#{schema}'
+          and     relkind in (#{kind_sql_list})
+      )
+    end
+
+    def column_exist_query(schema, relation, column)
+      %(
+        select  1
+        from    pg_class c
+        join    pg_attribute a on a.attrelid = c.oid
+        where   c.relnamespace::regnamespace::text = '#{schema}'
+        and     c.relname = '#{relation}'
+        and     a.attname = '#{column}'
+        and     a.attnum > 0
+      )
+    end
+
+    def column_list_query(schema, relation)
+      relation_clause = relation ? "relname = '#{relation}'" : nil
+      [
+          %(
+            select  '#{schema}' || '.' || c.relname || '.' || a.attname
+            from    pg_class c
+            join    pg_attribute a on a.attrelid = c.oid
+            where   relnamespace::regnamespace::text = '#{schema}'
+            and     a.attnum > 0
+          ), 
+          relation_clause
+      ].compact.join(" and ")
+    end
+  end
+end
+
+
+
+
+
+
+
+
+
+

data/lib/pg_conn/version.rb

@@ -0,0 +1,3 @@
+module PgConn
+  VERSION = "0.2.1"
+end

data/lib/pg_conn.rb

@@ -0,0 +1,677 @@
+require "pg"
+require 'ostruct'
+
+require "pg_conn/version"
+require "pg_conn/role_methods"
+require "pg_conn/schema_methods"
+require "pg_conn/rdbms_methods"
+
+module PgConn
+  class Error < StandardError; end
+
+  # Can be raised in #transaction blocks to rollback changes
+  class Rollback < Error; end
+
+  # Return a PgConn::Connection object. TODO: A block argument
+  def self.new(*args, &block) Connection.new(*args, &block) end
+
+  # Make the PgConn module pretend it has PgConn instances
+  def self.===(element) element.is_a?(PgConn::Connection) or super end
+
+  # Returns a PgConn::Connection object (aka. a PgConn object). It's arguments
+  # can be an existing connection that will just be returned of a set of
+  # PgConn::Connection#initialize arguments that will be used to create a new
+  # PgConn::Connection object
+  def self.ensure(*args)
+    if args.size == 1 && args.first.is_a?(PgConn::Connection)
+      args.first
+    else
+      PgConn::Connection.new(*args)
+    end
+  end
+
+  # All results from the database are converted into native Ruby types
+  class Connection
+    # Make PgConn::Connection pretend to be an instance of the PgConn module
+    def is_a?(klass) klass == PgConn or super end
+
+    # The PG::Connection object
+    attr_reader :pg_connection
+
+    # The class of column names (Symbol or String). Default is Symbol
+    attr_reader :field_name_class
+
+    # Name of user
+    def user() @pg_connection.user end
+    alias_method :username, :user # Obsolete
+
+    # Name of database
+    def name() @pg_connection.db end
+    alias_method :database, :name # Obsolete
+
+    # Database manipulation methods: #exist?, #create, #drop, #list. It is
+    # named 'rdbms' because #database is already defined
+    attr_reader :rdbms
+
+    # Role manipulation methods: #exist?, #create, #drop, #list
+    attr_reader :role
+
+    # Schema manipulation methods: #exist?, #create, #drop, #list, and
+    # #exist?/#list for relations/tables/views/columns
+    attr_reader :schema
+
+    # The transaction timestamp of the most recent SQL statement executed by
+    # #exec or #transaction block
+    attr_reader :timestamp
+
+          
+
+    # Initialize a connection object and connect to the database. #initialize has five
+    # variations:
+    #
+    #     initialize(dbname = nil, user = nil, field_name_class: Symbol)
+    #     initialize(connection_hash, field_name_class: Symbol)
+    #     initialize(connection_string, field_name_class: Symbol)
+    #     initialize(host, port, dbname, user, password, field_name_class: Symbol)
+    #     initialize(pg_connection_object)
+    #
+    # The possible keys of the connection hash are :host, :port, :dbname, :user,
+    # and :password. The connection string can either be a space-separated list
+    # of <key>=<value> pairs with the same keys as the hash, or a URI with the
+    # format 'postgres[ql]://[user[:password]@][host][:port][/name]
+    #
+    # The :field_name_class option controls the Ruby type of column names. It can be
+    # Symbol (the default) or String. The :timestamp option is used
+    # internally to set the timestamp for transactions
+    #
+    # The last variant is used to establish a PgConn from an existing
+    # connection. It doesn't change the connection settings and is not
+    # recommended except in cases where you want to piggyback on an existing
+    # connection (eg. a Rails connection)
+    #
+    # Note that the connection hash and the connection string may support more
+    # parameters than documented here. Consult
+    # https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING
+    # for the full list
+    #
+    def initialize(*args)
+      if args.last.is_a?(Hash)
+        @field_name_class = args.last.delete(:field_name_class) || Symbol
+        @timestamp = args.last.delete(:timestamp)
+        args.pop if args.last.empty?
+      else
+        @field_name_class = Symbol
+      end
+
+#     else # We assume that the current user is a postgres superuser
+#       @db = PgConn.new("template0")
+
+      using_existing_connection = false
+      @pg_connection =
+          if args.size == 0
+            make_connection
+          elsif args.size == 1
+            case arg = args.first
+              when PG::Connection
+                using_existing_connection = true
+                arg
+              when String
+                if arg =~ /=/
+                  make_connection arg
+                elsif arg =~ /\//
+                  make_connection arg
+                else
+                  make_connection dbname: arg
+                end
+              when Hash
+                make_connection **arg
+            else
+              raise Error, "Illegal argument type: #{arg.class}"
+            end
+          elsif args.size == 2
+            make_connection dbname: args.first, user: args.last
+          elsif args.size == 5
+            make_connection args[0], args[1], nil, nil, args[2], args[3], args[4]
+          else
+            raise Error, "Illegal number of parameters: #{args.size}"
+          end
+
+      if !using_existing_connection
+        # Auto-convert to ruby types
+        type_map = PG::BasicTypeMapForResults.new(@pg_connection) 
+
+        # Use String as default type. Kills 'Warning: no type cast defined for
+        # type "uuid" with oid 2950..' warnings
+        type_map.default_type_map = PG::TypeMapAllStrings.new
+
+        # Timestamp decoder
+        type_map.add_coder PG::TextDecoder::Timestamp.new( # Timestamp without time zone
+            oid: 1114, 
+            flags: PG::Coder::TIMESTAMP_DB_UTC | PG::Coder::TIMESTAMP_APP_UTC)
+
+        # Decode anonymous records but note that this is only useful to convert the
+        # outermost structure into an array, the elements are not decoded and are
+        # returned as strings. It is best to avoid anonymous records if possible
+        type_map.add_coder PG::TextDecoder::Record.new(
+            oid: 2249
+        )
+
+        @pg_connection.type_map_for_results = type_map
+        @pg_connection.field_name_type = @field_name_class.to_s.downcase.to_sym # Use symbol field names
+        @pg_connection.exec "set client_min_messages to warning;" # Silence warnings
+      end
+
+      @schema = SchemaMethods.new(self)
+      @role = RoleMethods.new(self)
+      @rdbms = RdbmsMethods.new(self)
+      @timestamp = nil
+      @savepoints = nil # Stack of savepoint names. Nil if no transaction in progress
+    end
+
+    # Close the database connection
+    def terminate()
+      @pg_connection.close if !@pg_connection.finished? 
+    end
+
+    def self.new(*args, &block)
+      if block_given?
+        begin
+          object = Connection.allocate
+          object.send(:initialize, *args)
+          yield(object) if object.pg_connection
+        ensure
+          object.terminate if object.pg_connection
+        end
+      else
+        super(*args)
+      end
+    end
+
+#   # Return true iff the query returns exactly one value
+#   def exist?(query) count(query) == 1 end
+
+    # :call-seq:
+    #   exist?(query)
+    #   exist?(table, id)
+    #   eists?(table, where_clause)
+    #
+    # Return true iff the query returns exactly one value
+    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
+    end
+
+    # :call-seq:
+    #   count(query)
+    #   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/
+        count("select 1 from (#{arg}) as inner_query")
+      else
+        count("select 1 from #{arg}" + (where_clause ? " where #{where_clause}" : ""))
+      end == 1
+    end
+
+    # :call-seq:
+    #   count(query)
+    #   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
+    end
+
+    # 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 be committed it :commit is true
+    # (the default). This can be used in 'insert ... returning ...' statements
+    def value(query) #, transaction: false, commit: true)
+      r = pg_exec(query)
+      check_1c(r)
+      check_1r(r)
+      r.values[0][0]
+    end
+
+    # 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)
+      check_1c(r)
+      return nil if r.ntuples == 0
+      check_1r(r)
+      r.values[0][0]
+    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)
+      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
+    # 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)
+      check_1r(r)
+      r.values[0]
+    end
+
+    # Like #tuple but returns nil if no record was found
+    def tuple?(query)
+      r = pg_exec(query)
+      return nil if r.ntuples == 0
+      check_1r(r)
+      r.values[0]
+    end
+
+    # 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
+    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)
+      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)
+      check_1c(r)
+      return nil if r.ntuples == 0
+      check_1r(r)
+      r.tuple(0).to_h
+    end
+
+    # Return an array of single-element hashes from column name to value. It
+    # 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)
+      check_1c(r)
+      r.each.to_a.map(&:to_h)
+    end
+
+    # 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)
+      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)
+      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)
+      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))
+    end
+
+    # Like #struct but returns nil if no record was found
+    def struct?(query)
+      args = record?(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) }
+    end
+
+    # Return a hash from the record id column to record (hash from column name
+    # to field value) If the :key_column option is defined it will be used
+    # instead of id as the key It is an error if the id field value is not
+    # unique
+    def table(query, key_column: :id)
+      [String, Symbol].include?(key_column.class) or raise "Illegal key_column"
+      key_column = (field_name_class == Symbol ? key_column.to_sym : key_column.to_s)
+      r = pg_exec(query)
+      begin
+        r.fnumber(key_column.to_s) # FIXME: What is this?
+      rescue ArgumentError
+        raise Error, "Can't find column #{key_column}"
+      end
+      h = {}
+      r.each { |record|
+        key = record[key_column]
+        !h.key?(key) or raise Error, "Duplicate key: #{key.inspect}"
+        h[record[key_column]] = record.to_h
+      }
+      h
+    end
+
+    # Return a hash from the record id column to an OpenStruct representation
+    # of the record. If the :key_column option is defined it will be used
+    # instead of id as the key It is an error if the id field value is not
+    # unique
+    def set(query, key_column: :id)
+      key_column = key_column.to_sym
+      keys = {}
+      r = pg_exec(query)
+      begin
+        r.fnumber(key_column.to_s) # Check that key column exists
+      rescue ArgumentError
+        raise Error, "Can't find column #{key_column}"
+      end
+      h = {}
+      for i in 0...r.ntuples
+        struct = OpenStruct.new(**r[i])
+        key = struct.send(key_column)
+        !h.key?(key) or raise Error, "Duplicate key: #{key.inspect}"
+        h[key] = struct
+      end
+      h
+    end
+
+    # 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)
+      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?(key_value) or raise Error, "Duplicate key: #{key_value}"
+        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). It dynamically detects the structure of the result and return
+    # a value or an array of values if the result contained only one column
+    # (like #value or #values), a tuple if the record has multiple columns
+    # (like #tuple), and an array of of tuples if the result contained more
+    # than one record with multiple columns (like #tuples)
+    def call(name, *args)
+      args_sql = args.map { |arg| # TODO: Use pg's encoder
+        case arg
+          when NilClass; "null"
+          when String; "'#{arg}'"
+          when Integer; arg
+          when TrueClass, FalseClass; arg
+          when Array; raise NotImplementedError
+          when Hash; raise NotImplementedError
+        else
+          raise ArgumentError, "Unrecognized value: #{arg.inspect}"
+        end
+      }.join(", ")
+      query = "select * from #{name}(#{args_sql})"
+      r = pg_exec(query)
+      if r.ntuples == 0
+        raise Error, "No records returned"
+      elsif r.ntuples == 1
+        if r.nfields == 1
+          r.values[0][0]
+        else
+          r.values[0]
+        end
+      elsif r.nfields == 1
+        r.column_values(0)
+      else
+        r.values
+      end
+    end
+
+    # Execute SQL statement(s) in a transaction and return the number of
+    # affected records (if any). Also sets #timestamp unless a transaction is
+    # already in progress. The +sql+ argument can be a String or an arbitrarily
+    # nested array of strings. The empty array is a NOP but the empty string is
+    # not.
+    #
+    # #exec pass Postgres exceptions to the caller unless :fail is false. If
+    # fail is false #exec instead return nil but note that postgres doesn't
+    # ignore it so that if you're inside a transaction, the transaction will be
+    # in an error state and if you're also using subtransactions the whole
+    # transaction stack collapses.
+    #
+    # TODO: Make sure the transaction stack is emptied on postgres errors
+    def exec(sql, commit: true, fail: true, silent: false)
+      transaction(commit: commit) { execute(sql, fail: fail, silent: silent) }
+    end
+
+    # Execute SQL statement(s) without a transaction block and return the
+    # number of affected records (if any). This used to call procedures that
+    # may manipulate transactions. The +sql+ argument can be a String or
+    # an arbitrarily nested array of strings. The empty array is a NOP but the
+    # empty string is not. #exec pass Postgres exceptions to the caller unless
+    # :fail is false in which case it returns nil
+    #
+    # TODO: Handle postgres exceptions wrt transaction state and stack
+    def execute(sql, fail: true, silent: false)
+      pg_exec(sql, fail: fail, silent: silent)&.cmd_tuples
+    end
+
+    # Switch user to the given user and execute the statement before swithcing
+    # back to the original user
+    #
+    # FIXME: The out-commented transaction block makes postspec fail for some reason
+    def su(username, &block)
+      raise Error, "Missing block in call to PgConn::Connection#su" if !block_given?
+      realuser = self.value "select current_user"
+      result = nil
+#     transaction(commit: false) {
+        execute "set session authorization #{username}"
+        result = yield
+        execute "set session authorization #{realuser}"
+#     }
+      result
+    end
+
+    # TODO: Move to TransactionMethods
+
+    def commit()
+      if transaction?
+        pop_transaction
+      else
+        pg_exec("commit")
+      end
+    end
+
+    def rollback() raise Rollback end
+
+    # True if a transaction is in progress
+    def transaction?() !@savepoints.nil? end
+
+    # Returns number of transaction or savepoint levels
+    def transactions() @savepoints ? 1 + @savepoints.size : 0 end
+
+    def push_transaction
+      if transaction?
+        savepoint = "savepoint_#{@savepoints.size + 1}"
+        @savepoints.push savepoint
+        pg_exec("savepoint #{savepoint}")
+      else
+        @savepoints = []
+        pg_exec("begin")
+        @timestamp = pg_exec("select current_timestamp").values[0][0]
+      end
+    end
+
+    def pop_transaction(commit: true)
+      transaction? or raise Error, "No transaction in progress"
+      if savepoint = @savepoints.pop
+        if !commit
+          pg_exec("rollback to savepoint #{savepoint}")
+          pg_exec("release savepoint #{savepoint}")
+        else
+          pg_exec("release savepoint #{savepoint}")
+        end
+      else
+        @savepoints = nil
+        pg_exec(commit ? "commit" : "rollback")
+      end
+    end
+
+    # Does a rollback and empties the stack. This should be called in response
+    # to PG::Error exceptions because then the whole transaction stack is
+    # invalid
+    def cancel_transaction
+      pg_exec("rollback")
+      @savepoints = nil
+    end
+
+    # Execute block within a transaction and return the result of the block.
+    # The transaction can be rolled back by raising a PgConn::Rollback
+    # exception in which case #transaction returns nil. Note that the
+    # transaction timestamp is set to the start of the first transaction even
+    # if transactions are nested
+    def transaction(commit: true, &block)
+      result = nil
+      begin
+        push_transaction
+        result = yield
+      rescue PgConn::Rollback
+        pop_trancaction(commit: false)
+        return nil
+      end
+      pop_transaction(commit: commit)
+      result
+    end
+
+  private
+    # Wrapper around PG::Connection.new that switches to the postgres user
+    # before connecting if the current user is the root user
+    #
+    def make_connection(*args, **opts)
+      if Process.euid == 0
+        begin
+          postgres_uid = Process::UID.from_name "postgres"
+        rescue ArgumentError
+          raise Error, "Can't find 'postgres' user"
+        end
+        begin
+          postgres_gid = Process::GID.from_name "postgres"
+        rescue ArgumentError
+          raise Error, "Can't find 'postgres' group"
+        end
+
+        begin
+          Process::Sys.seteuid postgres_uid
+          Process::Sys.setegid postgres_gid
+          PG::Connection.new *args, **opts
+        ensure
+          Process::Sys.seteuid 0
+          Process::Sys.setguid 0
+        end
+      else
+        PG::Connection.new *args, **opts
+      end
+    end
+        
+    # :call-seq:
+    #   pg_exec(string)
+    #   pg_exec(array)
+    #
+    # +arg+ can be a statement or an array of statements. The statements are
+    # concatenated before being sent to the server. It returns a PG::Result
+    # object or nil if +arg+ was empty. #exec pass Postgres exceptions to the
+    # caller unless :fail is false
+    #
+    # FIXME: Error message prints the last statement but what if another
+    # statement failed?
+    #
+    # TODO WILD: Parse sql and split it into statements that are executed
+    # one-by-one so we're able to pinpoint errors in the source
+    #
+    # TODO: Fix silent by not handling exceptions
+    def pg_exec(arg, fail: true, silent: false)
+      begin
+        last_stmt = nil # To make the current SQL statement visible to the rescue clause
+        if arg.is_a?(String)
+          return nil if arg == ""
+          last_stmt = arg
+          @pg_connection.exec(last_stmt)
+        else
+          stmts = arg.flatten.compact
+          return nil if stmts.empty?
+          last_stmt = stmts.last
+          @pg_connection.exec(stmts.join(";\n"))
+        end
+        
+      rescue PG::Error => ex
+        if fail
+          if !silent # FIXME Why do we handle this? 
+            $stderr.puts arg
+            $stderr.puts ex.message
+            $stderr.flush
+          end
+          raise
+        else
+          return nil
+        end
+      end
+    end
+
+    def check_1c(r) 
+      case r.nfields
+        when 0; raise Error, "No columns returned"
+        when 1; 
+      else
+        raise Error, "More than one column returned" 
+      end
+    end
+
+    def check_1r(r) 
+      if r.ntuples == 0
+        raise Error, "No records returned"
+      elsif r.ntuples > 1 
+        raise Error, "More than one record returned" 
+      end
+    end
+  end
+
+  def self.sql_values(values) "'" + values.join("', '") + "'" end
+  def self.sql_idents(values) '"' + values.join('", "') + '"' end
+end
+

data/pg_conn.gemspec

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "lib/pg_conn/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "pg_conn"
+  spec.version       = PgConn::VERSION
+  spec.authors       = ["Claus Rasmussen"]
+  spec.email         = ["claus.l.rasmussen@gmail.com"]
+
+  spec.summary       = "Gem pg_conn"
+  spec.description   = "Gem pg_conn"
+  spec.homepage      = "http://www.nowhere.com/"
+  spec.required_ruby_version = ">= 2.4.0"
+
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+
+  # Add your production dependencies here
+  # spec.add_dependency GEM [, VERSION]
+  spec.add_dependency "pg"
+
+  # Add your development dependencies here
+  # spec.add_development_dependency GEM [, VERSION]
+
+  # Also un-comment in spec/spec_helper to use simplecov
+  # spec.add_development_dependency "simplecov"
+
+  # In development mode override load paths for gems whose source are located
+  # as siblings of this project directory
+  if File.directory?("#{__dir__}/.git")
+    local_projects = Dir["../*"].select { |path| 
+      File.directory?(path) && File.exist?("#{path}/Gemfile")
+    }.map { |relpath| "#{File.absolute_path(relpath)}/lib" }
+    $LOAD_PATH.unshift *local_projects
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: pg_conn
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Claus Rasmussen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gem pg_conn
+email:
+- claus.l.rasmussen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- README.md
+- Rakefile
+- TODO
+- bin/console
+- bin/setup
+- lib/pg_conn.rb
+- lib/pg_conn/rdbms_methods.rb
+- lib/pg_conn/role_methods.rb
+- lib/pg_conn/schema_methods.rb
+- lib/pg_conn/version.rb
+- pg_conn.gemspec
+homepage: http://www.nowhere.com/
+licenses: []
+metadata:
+  homepage_uri: http://www.nowhere.com/
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.26
+signing_key: 
+specification_version: 4
+summary: Gem pg_conn
+test_files: []