pg_conn 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca254f7c17749713f46f07448221683e5975c570407aff61ee440f82a37466ca
-  data.tar.gz: 86486e52477bbf36009d69f9322061077b5860582e4fc7ced67e2d88bad5ee0b
+  metadata.gz: 25c23025d55818536e6d89bc5fa40b12ac296f0e61657db387f8a8732bdf3504
+  data.tar.gz: 7592d3a2b26d7f75f0ea88ad9b8f951422ced0cc913a387eb3f774b31bb1c4eb
 SHA512:
-  metadata.gz: b0981561372e9039eda5c8eb85948c63559e1875f4764dfaa3b32d52fa501b62522b2acde9a58036aa6978bb9b454cb66bec788e9d141dbc50b3ce5e14ee9941
-  data.tar.gz: 70a3927ceec9d61962002e301c817479e043878ec122ed1d265c9ed9372fb0abc744eaaf266e983b6352179f42e983752c030a12e878699c24b37fde8c6c663e
+  metadata.gz: 0701ef07551bc1db06b654aa12e957ca4ad2286f1050c122af95ce78670ea426e6bf8f566831070200588e2c844eaf70ddab0cc5147941ccdcf6f4dc232c4102
+  data.tar.gz: 5310090682a9c93a648823b477081eebe31c214554ebe06a44d2f6702ec18c3fd5eb43e16bad0c15178d48a6194e109dbf15adb8bb3f75e645b90581ef3bc948

data/lib/pg_conn/rdbms_methods.rb

@@ -69,8 +69,8 @@ module PgConn
     end
 
     # Hollow-out a database by removing all schemas in the database. The public
-    # schema is recreated afterwards unless if :public is false. Uses the
-    # current database if @database is nil
+    # schema is recreated afterwards unless :public is false. Uses the current
+    # database if @database is nil
     #
     # Note that the database can have active users logged in while the database
     # is emptied. TODO Explain what happens if the users have active
@@ -103,7 +103,7 @@ module PgConn
       create(to_database, owner: owner, template: from_database)
     end
 
-    # TODO: This code is replicated across many project. Should be moved to PgConn
+    # TODO: This code is replicated across many projects. Should be moved to PgConn
     def load(database, file, role: ENV['USER'], gzip: nil)
       command_opt = role ? "-c \"set role #{role}\";\n" : nil
       if gzip
@@ -118,7 +118,7 @@ module PgConn
       status == 0 or raise PsqlError.new(stderr)
     end
 
-    # TODO: This code is replicated across many project. Should be moved to PgConn
+    # TODO: This code is replicated across many projects. Should be moved to PgConn
     def save(database, file, data: true, schema: true, gzip: nil)
       data_opt = data ? nil : "--schema-only"
       schema_opt = schema ? nil : "--data-only"

data/lib/pg_conn/schema_methods.rb

@@ -35,6 +35,26 @@ module PgConn
       true
     end
 
+    # Hollow out a schema by dropping all tables and views (but still not
+    # functions and procedures TODO)
+    def empty!(schema, exclude: [])
+      self.list_tables(schema, exclude: exclude).each { |table|
+        conn.exec "drop table if exists #{schema}.#{table} cascade"
+      }
+      self.list_views(schema, exclude: exclude).each { |view|
+        conn.exec "drop view if exists #{schema}.#{view} cascade"
+      }
+    end
+
+    # Empty all tables in the given schema
+    def clean!(schema, exclude: [])
+      conn.session.triggers(false) {
+        self.list_tables(schema, exclude: exclude).each { |table| 
+          conn.exec "delete from #{schema}.#{table}" 
+        }
+      }
+    end
+
     # List schemas. 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: [])
@@ -53,7 +73,7 @@ module PgConn
 
     # Return true if table exists
     def exist_table?(schema, table)
-      conn.exist?(relation_exist_query(schema, table, kind: %w(r f)))
+      conn.exist? relation_exist_query(schema, table, kind: %w(r f))
     end
 
     # Return true if view exists
@@ -66,19 +86,22 @@ module PgConn
       conn.exist? column_exist_query(schema, relation, column)
     end
 
+    # TODO
+#   def exist_index?(schema, relation, FIXME)
+
     # Return list of relations in the schema
-    def list_relations(schema)
-      conn.values relation_list_query(schema)
+    def list_relations(schema, exclude: [])
+      conn.values relation_list_query(schema, exclude: exclude)
     end
 
     # Return list of tables in the schema
-    def list_tables(schema)
-      conn.values relation_list_query(schema, kind: %w(r f))
+    def list_tables(schema, exclude: [])
+      conn.values relation_list_query(schema, exclude: exclude, kind: %w(r f))
     end
 
     # Return list of view in the schema
-    def list_views(schema)
-      conn.values relation_list_query(schema, kind: %w(v m))
+    def list_views(schema, exclude: [])
+      conn.values relation_list_query(schema, exclude: exclude, kind: %w(v m))
     end
 
     # Return a list of columns. If +relation+ is defined, only columns from that
@@ -113,13 +136,18 @@ module PgConn
       )
     end
 
-    def relation_list_query(schema, kind: nil)
-      kind_sql_list = "'" + (kind.nil? ? %w(r f v m) : Array(kind).flatten).join("', '") + "'"
+    def relation_list_query(schema, exclude: nil, kind: nil)
+      kind_list = "'" + (kind.nil? ? %w(r f v m) : Array(kind).flatten).join("', '") + "'"
+      kind_expr = "relkind in (#{kind_list})"
+      exclude = Array(exclude || []).flatten
+      exclude_list = "'#{exclude.flatten.join("', '")}'" if !exclude.empty?
+      exclude_expr = exclude.empty? ? "true = true" : "not relname in (#{exclude_list})"
       %(
           select  relname
           from    pg_class 
           where   relnamespace::regnamespace::text = '#{schema}'
-          and     relkind in (#{kind_sql_list})
+          and     #{kind_expr}
+          and     #{exclude_expr}
       )
     end
 

data/lib/pg_conn/session_methods.rb

@@ -8,7 +8,8 @@ module PgConn
     end
 
     # Returns a list of users connected to the given database. If database is
-    # nil, it returns a list of database/username tuples for all connected users
+    # nil, it returns a list of database/username tuples for all connected
+    # users
     def list(database)
       if database
         conn.values "select usename from pg_stat_activity where datname = '#{database}'"
@@ -21,34 +22,52 @@ module PgConn
       end
     end
 
-    # Terminate sessions in the database of the given users or of all users if
-    # the users is nil. Note that 'terminate(database)' is a nop because the
-    # absent users argument defaults to an empty list
-    #
-    # TODO: Make is possible to terminate a single session of a user with
-    #       multiple sessions (is this ever relevant?)
-    def terminate(database, *users)
+    # Return true if the given database accepts connections
+    def enabled?(database) 
       !database.nil? or raise ArgumentError
-      users = Array(users).flatten
-      case users
-        when []; return
-        when [nil]; users = list(database)
-        else users = Array(users).flatten
-      end
-      pids = self.pids(database, users)
-      return if pids.empty?
-      pids_sql = pids.map { |pid| "(#{pid})" }.join(", ")
-      conn.execute "select pg_terminate_backend(pid) from ( values #{pids_sql} ) as x(pid)"
+      conn.value "select datallowconn from pg_catalog.pg_database where datname = '#{database}'"
     end
 
+    # Ensure connections to the given database are enabled
+    def enable(database)
+      !database.nil? or raise ArgumentError
+      conn.execute "alter database #{database} allow_connections = true"
+    end
+
+    # Ensure connections to the given database are disabled
     def disable(database)
       !database.nil? or raise ArgumentError
       conn.execute "alter database #{database} allow_connections = false"
     end
 
-    def enable(database)
+    # TODO: Why not let a nil database argument have the current database as default?
+
+    # Terminate sessions in the database of the given users or of all users if
+    # nil. Note that 'terminate(database)' is a nop because the absent users
+    # argument defaults to an empty list
+    #
+    # TODO: Make is possible to terminate a single session of a user with
+    #       multiple sessions (is this ever relevant?)
+    #
+    def terminate(database, *users)
       !database.nil? or raise ArgumentError
-      conn.execute "alter database #{database} allow_connections = true"
+      enabled = self.enabled?(database)
+
+      case users
+        when []; 
+          return
+        when [nil]
+          self.disable(database) if enabled
+          users = self.list(database)
+        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)"
+      end
+      self.enable(database) if self.enabled?(database) != enabled
     end
 
     # Run block without any connected users. Existing sessions are terminated
@@ -56,14 +75,46 @@ module PgConn
       !database.nil? or raise ArgumentError
       begin
         disable(database)
-        users = list(database)
-        terminate(database, users)
+        terminate(database, nil)
         yield
       ensure
         enable(database)
       end
     end
 
+    # 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 = replica"
+    end
+
+    # Disable session triggers
+    def disable_triggers()
+      conn.execute "set session session_replication_role = DEFAULT"
+    end
+
+    # Execute block with session triggers on or off
+    def triggers(on_off, &block)
+      begin
+        active = triggers?
+        if on_off && !active
+          enable_triggers
+        elsif !on_off && active
+          disable_triggers
+        end
+        yield
+      ensure
+        if on_off && !active
+          disable_triggers
+        elsif !on_off && active
+          enable_triggers
+        end
+      end
+    end
+
   private
     # Like #list but returns the PIDs of the users
     def pids(database, users)

data/lib/pg_conn/version.rb

@@ -1,3 +1,3 @@
 module PgConn
-  VERSION = "0.15.0"
+  VERSION = "0.16.0"
 end

data/lib/pg_conn.rb

@@ -67,9 +67,15 @@ module PgConn
     # #exec or #transaction block
     attr_reader :timestamp
 
-    # PG::Error object if the last statement failed; otherwise nil
+    # PG::Error object of the first failed statement in the transaction;
+    # otherwise nil. It is cleared at the beginning of a transaction so be sure
+    # to save it before you run any cleanup code that may initiate new
+    # transactions
     attr_reader :error
 
+    # True if the transaction is in a error state
+    def error?() !@error.nil? end
+
     # Tuple of error message, lineno, and charno of the error object where each
     # element defaults to nil if not found
     def err
@@ -607,24 +613,17 @@ module PgConn
     #
     # TODO: Make sure the transaction stack is emptied on postgres errors
     def exec(sql, commit: true, fail: true, silent: false)
-      begin
-        transaction(commit: commit) { execute(sql, fail: fail, silent: silent) }
-      rescue PG::Error
-        raise if fail
-        cancel_transaction
-        return nil
-      end
+      transaction(commit: commit) { execute(sql, fail: fail, silent: silent) }
     end
 
     # Like #exec but returns true/false depending on if the command succeeded.
-    # There is not corresponding #exeucte? method because any failure rolls
+    # There is not a corresponding #execute? method because any failure rolls
     # back the whole transaction stack. TODO: Check which exceptions that
     # should be captured
     def exec?(sql, commit: true, silent: true) 
       begin
         exec(sql, commit: commit, fail: true, silent: silent)
       rescue PG::Error
-        cancel_transaction
         return false
       end
       return true
@@ -643,6 +642,7 @@ module PgConn
         begin
           pg_exec(sql, silent: silent)&.cmd_tuples
         rescue PG::Error
+          cancel_transaction
           raise if fail
           return nil
         end
@@ -672,7 +672,7 @@ module PgConn
 
     def commit()
       if transaction?
-        pop_transaction
+        pop_transaction(fail: false)
       else
         pg_exec("commit")
       end
@@ -680,11 +680,18 @@ module PgConn
 
     def rollback() raise Rollback end
 
-    # True if a transaction is in progress. Note that this requires all
-    # transactions to be started using PgConn's transaction methods;
-    # transactions started using raw SQL are not registered
+    # True if a transaction is in progress
+    #
+    # Note that this requires all transactions to be started using PgConn's
+    # transaction methods; transactions started using raw SQL are not
+    # registered
     def transaction?() !@savepoints.nil? end
 
+    # True if a database transaction is in progress
+    def database_transaction?
+      pg_exec("select transaction_timestamp() != statement_timestamp()", fail: false)
+    end
+
     # Returns number of transaction or savepoint levels
     def transactions() @savepoints ? 1 + @savepoints.size : 0 end
 
@@ -696,11 +703,12 @@ module PgConn
       else
         @savepoints = []
         pg_exec("begin")
+        @error = @err = nil
         @timestamp = pg_exec("select current_timestamp").values[0][0] if @pg_connection
       end
     end
 
-    def pop_transaction(commit: true, fail: true)
+    def pop_transaction(commit: true, fail: true, exception: true)
       if transaction?
         if savepoint = @savepoints.pop
           if !commit
@@ -728,8 +736,10 @@ module PgConn
       begin
         pg_exec("rollback")
       rescue PG::Error
+        ;
       end
       @savepoints = nil
+      true
     end
 
     # Start a transaction. If called with a block, the block is executed within
@@ -748,13 +758,14 @@ module PgConn
           push_transaction
           result = yield
         rescue PgConn::Rollback
-          pop_transaction(commit: false)
+          pop_transaction(commit: false, fail: false)
           return nil
         rescue PG::Error
+          cancel_transaction
           @savepoints = nil
           raise
         end
-        pop_transaction(commit: commit)
+        pop_transaction(commit: commit, fail: false)
         result
       else
         push_transaction
@@ -812,7 +823,6 @@ module PgConn
     # TODO: Fix silent by not handling exceptions
     def pg_exec(arg, silent: false)
       if @pg_connection
-        @error = @err = nil
         begin
           last_stmt = nil # To make the current SQL statement visible to the rescue clause. FIXME Not used?
           if arg.is_a?(String)
@@ -826,9 +836,11 @@ module PgConn
             last_stmt = stmts.last
             @pg_connection.exec(stmts.join(";\n"))
           end
-          
         rescue PG::Error => ex
-          @error = ex
+          if @error.nil?
+            @error = ex
+            @err = nil
+          end
           if !silent # FIXME Why do we handle this? 
             $stderr.puts arg
             $stderr.puts

metadata

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