pg_conn 0.15.1 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ebb0df0000ecb59d313c906b608bdd267aaef84edcb4be633650601c453768b
-  data.tar.gz: 96d5e1db6d3644fef73dbb69f50acd7deec6dc79404641615d034586d1fddcf0
+  metadata.gz: b6f8840c223cb2dd9a6a5f8b2211e43184eb308114ffdd8bdc76d92f6ea03e16
+  data.tar.gz: fbfad4033c2d21abb91b726c183001d4edbaf348d61cb425b4b003dd89a37f35
 SHA512:
-  metadata.gz: 1cba9680627ce4ba4c5b8aa3df5505ab407e6096c26560799680a340640cef3b6a107319c58c1230ee130f1811d569367f8819d81f1be957069703b03d0bbb8b
-  data.tar.gz: 4c578bd594f740f9b07d288a1ae37de9d54cee7009da5f4d493a58ed324821cd4258ebce916ddfd68527e773c4396cd866da8054d4558d31c95962c6fd9ce9d1
+  metadata.gz: fe6647045b3bad635ed480e201967a20f0b11b5fd71bcbdec6766b6a2f056e3b0c8de045e87f56af90fb429130b2a9f105c46f5de5de31219b8384d18b27b3ca
+  data.tar.gz: 5e114bd53908faf4a881799035276151ace147c63156cc006359e6483c182d0522d2a724f4e7b4fd551914739b23240c06a55319b46d4aa68c6bf65f0f8da095

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
@@ -101,6 +124,45 @@ module PgConn
       raise NotImplementedError
     end
 
+    # Return name of the table's sequence (if any)
+    def sequence(schema, table) 
+      conn.value "select pg_get_serial_sequence('#{schema}.#{table}', 'id')" 
+    end
+
+    # Get the current serial value for the table. Returns nil if the serial has
+    # not been used. If :next is true, the next value will be returned
+    def get_serial(schema, table, next: false)
+      uid = "#{schema}.#{table}"
+      next_option = binding.local_variable_get(:next) # because 'next' is a keyword
+
+      seq = sequence(schema, table) or raise ArgumentError, "Table #{uid} does not have a sequence"
+      value = conn.value %(
+        select
+          case is_called
+            when true then last_value
+            else null
+          end as "value"
+        from
+          #{seq}
+      )
+      if next_option
+        value&.+(1) || 1
+      else
+        value
+      end
+    end
+
+    # Set the serial value for the table
+    def set_serial(schema, table, value)
+      uid = "#{schema}.#{table}"
+      seq = sequence(schema, table) or raise ArgumentError, "Table #{uid} does not have a sequence"
+      if value
+        conn.exec "select setval('#{seq}', #{value})"
+      else
+        conn.exec "select setval('#{seq}', 1, false)"
+      end
+    end
+
   private
     def relation_exist_query(schema, relation, kind: nil)
       kind_sql_list = "'" + (kind.nil? ? %w(r f v m) : Array(kind).flatten).join("', '") + "'"
@@ -113,13 +175,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.1"
+  VERSION = "0.17.0"
 end

data/lib/pg_conn.rb

@@ -73,6 +73,9 @@ module PgConn
     # 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

metadata

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