better_record 0.22.9 → 0.23.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91f13fbd6a8dc65f36431f809f4abbee9e3efb4e1f5463dfe6bfc6da36e9b79b
-  data.tar.gz: 8441806856eacd6c530680d9184c19363bf15b8060e4198ea1f260ebe893d3fc
+  metadata.gz: 60c961a739971ab307f28b0d8a9a79dd037bacf16ece71be8ba1d6359593a079
+  data.tar.gz: e9f0b3840fe6a3f33f284e32c08cfe4a212ffd923ea631f777a05bdf5678c98e
 SHA512:
-  metadata.gz: e351916c382db5ca42772ea5ba8034d978bf069caa9338bb3c6785db209ce72722761e15afcbc6d8f0b5bab6ab4ab7e4cbf39f51d3e5cc73f25aa9113e5826bb
-  data.tar.gz: 2c345b65982a8376b0f978ac899d1b8f392fcfecf12bd21aa07d1fef72053dfb196bba3f48b6b0b388e9d44016d1a06039aa4058659a3dc875c2faf5b6716d5e
+  metadata.gz: 3da0e6cfafcde379dd4a14fe3eb4fdc80f75ab17392325f6e0e137d3017116c5fc0551628ae6bb21e3c6e585c6c736f12e1c0ead6c0094930bf62bb200c02f88
+  data.tar.gz: 732e52e899620a71718b8d6b8b159f4b485fa43d7145b2e2d8dd0efd1ea43b98ed52502b083e04ababa81f461baab9791f41680b2784f3194e9cc003bce960b9

data/app/models/better_record/base.rb

@@ -57,6 +57,54 @@ module BetterRecord
       select(cq).limit(1).first[:"hashed_cert_#{t}"]
     end
 
+    def self.schema_qualified
+      return @schema_qualified if @schema_qualified.present?
+      if table_name =~ /.+\..+/
+        tmp_name = table_name.split('.')
+        @schema_qualified = {
+          schema_name: tmp_name[0],
+          table_name: tmp_name[1]
+        }
+      else
+        paths = (connection.execute("show search_path").first || {})['search_path']
+        paths = (paths.presence || "public").to_s.split(",")
+        paths.each do |schema_path|
+          row = (
+            connection.execute <<-SQL.cleanup_production
+              SELECT c.oid,
+                n.nspname,
+                c.relname
+              FROM pg_catalog.pg_class c
+                LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+              WHERE c.relname = '#{table_name}'
+                AND n.nspname = '#{schema_path.strip}'
+              ORDER BY 2, 3;
+            SQL
+          ).first
+
+          if row.present?
+            @schema_name = {
+              schema_name: row['nspname'],
+              table_name: row['relname']
+            }
+            break
+          end
+        end
+        return @schema_name || {
+          schema_name: "public",
+          table_name: table_name
+        }
+      end
+    end
+
+    def self.full_table_name
+      "#{schema_qualified[:schema_name]}.#{schema_qualified[:table_name]}"
+    end
+
+    def self.table_name_only
+      schema_qualified[:table_name]
+    end
+
     # == Boolean Methods ======================================================
 
     # == Instance Methods =====================================================
@@ -82,7 +130,14 @@ module BetterRecord
     if (ha = BetterRecord.has_auditing_relation_by_default)
       has_many self.audit_relation_name,
         class_name: 'BetterRecord::LoggedAction',
-        primary_type: :table_name,
+        primary_type: :full_table_name,
+        foreign_key: :row_id,
+        foreign_type: :full_name,
+        as: self.audit_relation_name
+
+      has_many :"#{self.audit_relation_name}_full_table",
+        class_name: 'BetterRecord::LoggedAction',
+        primary_type: :table_name_only,
         foreign_key: :row_id,
         foreign_type: :table_name,
         as: self.audit_relation_name

data/app/models/better_record/logged_action.rb

@@ -38,7 +38,7 @@ module BetterRecord
       [
         :event_id,
         :row_id,
-        :table_name,
+        :full_name,
         :app_user_id,
         :app_user_type,
         :action_type,

data/db/migrate/20190209195134_audit_trigger_v3.rb

@@ -6,7 +6,8 @@ class AuditTriggerV3 < ActiveRecord::Migration[5.2]
       SELECT pg_inherits.*, c.relname AS child, p.relname AS parent
       FROM
       pg_inherits JOIN pg_class AS c ON (inhrelid=c.oid)
-      JOIN pg_class as p ON (inhparent=p.oid);
+      JOIN pg_class as p ON (inhparent=p.oid)
+      WHERE p.relnamespace::regnamespace::text = '#{BetterRecord.db_audit_schema}';
     SQL
 
     children.each do |child|
@@ -91,7 +92,7 @@ class AuditTriggerV3 < ActiveRecord::Migration[5.2]
 
     rows.each do |r|
       if r['tgname'].to_s =~ /audit_trigger/
-        puts "\n\nPLEASE RECREATE ALL AUDIT TRIGGERS FOR #{r['table_name']}\n\n#{r}\n\n"
+        puts "\n\nPLEASE RECREATE ALL AUDIT TRIGGERS FOR #{r['schema_name']}.#{r['table_name']}\n\n#{r}\n\n"
       end
     end
 

data/db/migrate/20190823220215_audit_trigger_v4.rb

@@ -0,0 +1,162 @@
+class AuditTriggerV4 < ActiveRecord::Migration[5.2]
+  def up
+    execute <<-SQL
+      DROP TABLE IF EXISTS #{BetterRecord.db_audit_schema}.old_old_logged_actions CASCADE;
+      DROP TABLE IF EXISTS #{BetterRecord.db_audit_schema}.old_logged_actions CASCADE;
+      DROP SEQUENCE IF EXISTS #{BetterRecord.db_audit_schema}.old_logged_actions_event_id_seq;
+    SQL
+
+    children = execute <<-SQL
+      SELECT pg_inherits.*, c.relname AS child, p.relname AS parent
+      FROM
+      pg_inherits JOIN pg_class AS c ON (inhrelid=c.oid)
+      JOIN pg_class as p ON (inhparent=p.oid)
+      WHERE p.relnamespace::regnamespace::text = '#{BetterRecord.db_audit_schema}';
+    SQL
+
+    children.each do |child|
+      execute <<-SQL
+        ALTER TABLE #{BetterRecord.db_audit_schema}.#{child['child']}
+        RENAME TO #{'old_' * child['parent'].split('old_').size}#{child['child']}
+      SQL
+    end
+
+    # seq = execute <<-SQL
+    #   SELECT table_name, column_name, column_default from
+    #   information_schema.columns where table_name='old_old_logged_actions' AND column_name = 'event_id';
+    # SQL
+    #
+    # seq = seq.first
+    #
+    # val = "nextval('#{BetterRecord.db_audit_schema}.logged_actions_event_id_seq1'::regclass)"
+
+    rows = execute <<-SQL
+        SELECT trg.tgname,
+            CASE trg.tgtype::integer & 66
+                WHEN 2 THEN 'BEFORE'
+                WHEN 64 THEN 'INSTEAD OF'
+                ELSE 'AFTER'
+            END AS trigger_type,
+            CASE trg.tgtype::integer & cast(28 as int2)
+                WHEN 16 THEN 'UPDATE'
+                WHEN 8 THEN 'DELETE'
+                WHEN 4 THEN 'INSERT'
+                WHEN 20 THEN 'INSERT, UPDATE'
+                WHEN 28 THEN 'INSERT, UPDATE, DELETE'
+                WHEN 24 THEN 'UPDATE, DELETE'
+                WHEN 12 THEN 'INSERT, DELETE'
+            END AS trigger_event,
+            tbl.relname AS table_name,
+            tbl.relnamespace::regnamespace AS schema_name,
+            obj_description(trg.oid) AS remarks,
+            CASE
+                WHEN trg.tgenabled='O' THEN 'ENABLED'
+                ELSE 'DISABLED'
+            END AS status,
+            CASE trg.tgtype::integer & 1
+                WHEN 1 THEN 'ROW'::text
+                ELSE 'STATEMENT'::text
+            END AS trigger_level
+        FROM pg_trigger trg
+            JOIN pg_class tbl on trg.tgrelid = tbl.oid
+            JOIN pg_namespace ns ON ns.oid = tbl.relnamespace
+        WHERE trg.tgname not like 'RI_ConstraintTrigger%'
+            AND trg.tgname not like 'pg_sync_pg%'
+    SQL
+
+    rows.each do |r|
+      if r['tgname'].to_s =~ /audit_trigger/
+        execute "DROP TRIGGER IF EXISTS #{r['tgname']} ON #{r['schema_name']}.#{r['table_name']} CASCADE;"
+      end
+    end
+
+
+    execute <<-SQL
+      ALTER SEQUENCE IF EXISTS #{BetterRecord.db_audit_schema}.logged_actions_event_id_seq RENAME TO old_logged_actions_event_id_seq;
+      ALTER TABLE #{BetterRecord.db_audit_schema}.logged_actions RENAME TO old_logged_actions
+    SQL
+
+    sql = ""
+    source = File.new(BetterRecord::Engine.root.join('db', 'postgres-audit-v4-table.psql'), "r")
+    while (line = source.gets)
+      sql << line.gsub(/SELECTED_SCHEMA_NAME/, BetterRecord.db_audit_schema)
+    end
+    source.close
+
+    execute sql
+
+    sql = ""
+    source = File.new(BetterRecord::Engine.root.join('db', 'postgres-audit-v4-trigger.psql'), "r")
+    while (line = source.gets)
+      sql << line.gsub(/SELECTED_SCHEMA_NAME/, BetterRecord.db_audit_schema)
+    end
+    source.close
+
+    execute sql
+
+    puts ''
+
+    rows.each do |r|
+      if r['tgname'].to_s =~ /audit_trigger/
+        puts <<-TEXT
+          PLEASE RECREATE ALL AUDIT TRIGGERS FOR #{r['table_name']}
+          #{r}
+
+        TEXT
+      end
+    end
+
+    puts "\n\nTo insert old audits back into logged_actions run:\n\n"
+
+    puts <<-RUBY
+      INSERT INTO #{BetterRecord.db_audit_schema}.logged_actions_view
+      (
+        schema_name,
+        table_name,
+        full_name,
+        relid,
+        session_user_name,
+        app_user_id,
+        app_user_type,
+        app_ip_address,
+        action_tstamp_tx,
+        action_tstamp_stm,
+        action_tstamp_clk,
+        transaction_id,
+        application_name,
+        client_addr,
+        client_port,
+        client_query,
+        action,
+        row_id,
+        row_data,
+        changed_fields,
+        statement_only
+      )
+      SELECT
+        schema_name,
+        table_name,
+        schema_name || '.' || table_name,
+        relid,
+        session_user_name,
+        app_user_id,
+        app_user_type,
+        app_ip_address,
+        action_tstamp_tx,
+        action_tstamp_stm,
+        action_tstamp_clk,
+        transaction_id,
+        application_name,
+        client_addr,
+        client_port,
+        client_query,
+        action,
+        row_id,
+        row_data,
+        changed_fields,
+        statement_only
+      FROM #{BetterRecord.db_audit_schema}.old_logged_actions
+      ORDER BY old_logged_actions.event_id;
+    RUBY
+  end
+end

data/db/postgres-audit-v4-table.psql

@@ -0,0 +1,85 @@
+CREATE EXTENSION IF NOT EXISTS hstore;
+
+CREATE SCHEMA IF NOT EXISTS SELECTED_SCHEMA_NAME;
+REVOKE ALL ON SCHEMA SELECTED_SCHEMA_NAME FROM public;
+
+COMMENT ON SCHEMA SELECTED_SCHEMA_NAME IS 'Out-of-table audit/history logging tables and trigger functions';
+
+--
+-- Audited data. Lots of information is available, it's just a matter of how much
+-- you really want to record. See:
+--
+--   http://www.postgresql.org/docs/9.1/static/functions-info.html
+--
+-- Remember, every column you add takes up more audit table space and slows audit
+-- inserts.
+--
+-- Every index you add has a big impact too, so avoid adding indexes to the
+-- audit table unless you REALLY need them. The hstore GIST indexes are
+-- particularly expensive.
+--
+-- It is sometimes worth copying the audit table, or a coarse subset of it that
+-- you're interested in, into a temporary table where you CREATE any useful
+-- indexes and do your analysis.
+--
+CREATE TABLE IF NOT EXISTS SELECTED_SCHEMA_NAME.logged_actions (
+  event_id bigserial primary key,
+  schema_name text not null,
+  table_name text not null,
+  full_name text not null,
+  relid oid not null,
+  session_user_name text,
+  app_user_id integer,
+  app_user_type text,
+  app_ip_address inet,
+  action_tstamp_tx TIMESTAMP WITH TIME ZONE NOT NULL,
+  action_tstamp_stm TIMESTAMP WITH TIME ZONE NOT NULL,
+  action_tstamp_clk TIMESTAMP WITH TIME ZONE NOT NULL,
+  transaction_id bigint,
+  application_name text,
+  client_addr inet,
+  client_port integer,
+  client_query text,
+  action TEXT NOT NULL CHECK (action IN ('I','D','U', 'T', 'A')),
+  row_id bigint,
+  row_data hstore,
+  changed_fields hstore,
+  statement_only boolean not null
+);
+
+REVOKE ALL ON SELECTED_SCHEMA_NAME.logged_actions FROM public;
+
+COMMENT ON TABLE SELECTED_SCHEMA_NAME.logged_actions IS 'History of auditable actions on audited tables, from SELECTED_SCHEMA_NAME.if_modified_func()';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.event_id IS 'Unique identifier for each auditable event';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.schema_name IS 'Database schema audited table for this event is in';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.table_name IS 'Non-schema-qualified table name of table event occured in';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.full_name IS 'schema-qualified table name of table event occured in';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.relid IS 'Table OID. Changes with drop/create. Get with ''tablename''::regclass';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.session_user_name IS 'Login / session user whose statement caused the audited event';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.app_user_id IS 'Application-provided polymorphic user id';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.app_user_type IS 'Application-provided polymorphic user type';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.app_ip_address IS 'Application-provided ip address of user whose statement caused the audited event';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.action_tstamp_tx IS 'Transaction start timestamp for tx in which audited event occurred';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.action_tstamp_stm IS 'Statement start timestamp for tx in which audited event occurred';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.action_tstamp_clk IS 'Wall clock time at which audited event''s trigger call occurred';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.transaction_id IS 'Identifier of transaction that made the change. May wrap, but unique paired with action_tstamp_tx.';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.client_addr IS 'IP address of client that issued query. Null for unix domain socket.';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.client_port IS 'Remote peer IP port address of client that issued query. Undefined for unix socket.';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.client_query IS 'Top-level query that caused this auditable event. May be more than one statement.';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.application_name IS 'Application name set when this audit event occurred. Can be changed in-session by client.';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.action IS 'Action type; I = insert, D = delete, U = update, T = truncate, A = archive';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.row_id IS 'Record primary_key. Null for statement-level trigger. Prefers NEW.id if exists';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.row_data IS 'Record value. Null for statement-level trigger. For INSERT this is the new tuple. For DELETE and UPDATE it is the old tuple.';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.changed_fields IS 'New values of fields changed by UPDATE. Null except for row-level UPDATE events.';
+COMMENT ON COLUMN SELECTED_SCHEMA_NAME.logged_actions.statement_only IS '''t'' if audit event is from an FOR EACH STATEMENT trigger, ''f'' for FOR EACH ROW';
+
+CREATE INDEX IF NOT EXISTS logged_actions_relid_idx ON SELECTED_SCHEMA_NAME.logged_actions(relid);
+CREATE INDEX IF NOT EXISTS logged_actions_table_name_idx ON SELECTED_SCHEMA_NAME.logged_actions(table_name);
+CREATE INDEX IF NOT EXISTS logged_actions_full_name_idx ON SELECTED_SCHEMA_NAME.logged_actions(full_name);
+CREATE INDEX IF NOT EXISTS logged_actions_action_tstamp_tx_stm_idx ON SELECTED_SCHEMA_NAME.logged_actions(action_tstamp_stm);
+CREATE INDEX IF NOT EXISTS logged_actions_action_idx ON SELECTED_SCHEMA_NAME.logged_actions(action);
+CREATE INDEX IF NOT EXISTS logged_actions_row_id_idx ON SELECTED_SCHEMA_NAME.logged_actions(row_id);
+
+DROP VIEW IF EXISTS SELECTED_SCHEMA_NAME.logged_actions_view CASCADE;
+CREATE OR REPLACE VIEW SELECTED_SCHEMA_NAME.logged_actions_view AS SELECT * FROM SELECTED_SCHEMA_NAME.logged_actions;
+ALTER VIEW SELECTED_SCHEMA_NAME.logged_actions_view ALTER COLUMN event_id SET DEFAULT NEXTVAL('"SELECTED_SCHEMA_NAME"."logged_actions_event_id_seq"');

data/db/postgres-audit-v4-trigger.psql

@@ -0,0 +1,358 @@
+-- An audit history is important on most tables. Provide an audit trigger that logs to
+-- a dedicated audit table for the major relations.
+--
+-- This file should be generic and not depend on application roles or structures,
+-- as it's being listed here:
+--
+--  https://wiki.postgresql.org/wiki/Audit_trigger_91plus
+--
+-- This trigger was originally based on
+--   http://wiki.postgresql.org/wiki/Audit_trigger
+-- but has been completely rewritten.
+--
+-- Should really be converted into a relocatable EXTENSION, with control and upgrade files.
+
+DO $$ BEGIN
+  CREATE TYPE temp_table_info AS (schema_name TEXT, table_name TEXT);
+EXCEPTION
+  WHEN duplicate_object THEN null;
+END $$;
+
+CREATE OR REPLACE FUNCTION SELECTED_SCHEMA_NAME.get_table_information(target_table regclass)
+RETURNS temp_table_info AS
+$$
+  DECLARE
+    table_row record;
+    info_row temp_table_info;
+  BEGIN
+
+    FOR table_row IN SELECT * FROM pg_catalog.pg_class WHERE oid = target_table LOOP
+      info_row.schema_name = table_row.relnamespace::regnamespace::TEXT;
+      info_row.table_name = table_row.relname::TEXT;
+    END LOOP;
+    return info_row;
+  END;
+$$
+LANGUAGE plpgsql;
+
+COMMENT ON FUNCTION SELECTED_SCHEMA_NAME.get_table_information(regclass) IS
+$$
+  Get unqualified table name and schema name from a table regclass.
+
+  Arguments:
+      target_table: Table name, schema qualified if not on search_path
+$$;
+
+
+CREATE OR REPLACE FUNCTION SELECTED_SCHEMA_NAME.get_primary_key_column(target_table text)
+RETURNS text AS
+$$
+  DECLARE
+    _pk_query_text text;
+    _pk_column_name text;
+  BEGIN
+    _pk_query_text =  'SELECT a.attname ' ||
+                      'FROM   pg_index i ' ||
+                      'JOIN   pg_attribute a ON a.attrelid = i.indrelid ' ||
+                      '                    AND a.attnum = ANY(i.indkey) ' ||
+                      'WHERE  i.indrelid = ' || quote_literal(target_table::TEXT) || '::regclass ' ||
+                      'AND    i.indisprimary ' ||
+                      'AND format_type(a.atttypid, a.atttypmod) = ' || quote_literal('bigint'::TEXT) ||
+                      'LIMIT 1';
+
+    EXECUTE _pk_query_text INTO _pk_column_name;
+    return _pk_column_name;
+  END;
+$$
+LANGUAGE plpgsql;
+
+COMMENT ON FUNCTION SELECTED_SCHEMA_NAME.get_primary_key_column(text) IS
+$$
+  Get primary key column name if single PK and type bigint.
+
+  Arguments:
+      target_table:   Table name, schema qualified if not on search_path
+$$;
+
+
+CREATE OR REPLACE FUNCTION SELECTED_SCHEMA_NAME.skip_logged_actions_main()
+RETURNS TRIGGER
+AS $$
+  BEGIN
+    raise exception 'insert on wrong table';
+    RETURN NULL;
+  END;
+$$
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = pg_catalog, public;
+
+DROP TRIGGER IF EXISTS logged_actions_skip_direct ON SELECTED_SCHEMA_NAME.logged_actions;
+CREATE TRIGGER logged_actions_skip_direct BEFORE INSERT ON SELECTED_SCHEMA_NAME.logged_actions EXECUTE PROCEDURE SELECTED_SCHEMA_NAME.skip_logged_actions_main();
+
+CREATE OR REPLACE FUNCTION SELECTED_SCHEMA_NAME.logged_actions_partition()
+RETURNS TRIGGER AS
+$$
+  DECLARE
+    table_name text;
+    table_info temp_table_info;
+  BEGIN
+    table_info = SELECTED_SCHEMA_NAME.get_table_information(NEW.table_name::regclass);
+
+    table_name = table_info.table_name::TEXT;
+
+    EXECUTE 'CREATE TABLE IF NOT EXISTS SELECTED_SCHEMA_NAME.logged_actions_' || quote_ident(table_name) || '(
+      CHECK (table_name = ' || quote_literal(table_info.table_name) || '),
+      LIKE SELECTED_SCHEMA_NAME.logged_actions INCLUDING ALL
+    ) INHERITS (SELECTED_SCHEMA_NAME.logged_actions)';
+
+    EXECUTE 'INSERT INTO SELECTED_SCHEMA_NAME.logged_actions_' || quote_ident(table_name) || ' VALUES ($1.*)' USING NEW;
+
+    RETURN NEW;
+  END;
+$$
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = pg_catalog, public;
+
+DROP TRIGGER IF EXISTS logged_actions_partition_by_table ON SELECTED_SCHEMA_NAME.logged_actions_view;
+CREATE TRIGGER logged_actions_partition_by_table INSTEAD OF INSERT ON SELECTED_SCHEMA_NAME.logged_actions_view
+  FOR each ROW EXECUTE PROCEDURE SELECTED_SCHEMA_NAME.logged_actions_partition();
+
+CREATE OR REPLACE FUNCTION SELECTED_SCHEMA_NAME.if_modified_func()
+RETURNS TRIGGER AS
+$$
+  DECLARE
+    audit_row SELECTED_SCHEMA_NAME.logged_actions;
+    include_values boolean;
+    log_diffs boolean;
+    h_old hstore;
+    h_new hstore;
+    user_row record;
+    excluded_cols text[] = ARRAY[]::text[];
+    pk_val_query text;
+  BEGIN
+    IF TG_WHEN <> 'AFTER' THEN
+      RAISE EXCEPTION 'SELECTED_SCHEMA_NAME.if_modified_func() may only run as an AFTER trigger';
+    END IF;
+
+    audit_row = ROW(
+      nextval('SELECTED_SCHEMA_NAME.logged_actions_event_id_seq'), -- event_id
+      TG_TABLE_SCHEMA::text,                                       -- schema_name
+      TG_TABLE_NAME::text,                                         -- table_name
+      TG_TABLE_SCHEMA::text || '.' || TG_TABLE_NAME::text,         -- full_name
+      TG_RELID,                                                    -- relation OID for much quicker searches
+      session_user::text,                                          -- session_user_name
+      NULL, NULL, NULL,                                            -- app_user_id, app_user_type, app_ip_address
+      current_timestamp,                                           -- action_tstamp_tx
+      statement_timestamp(),                                       -- action_tstamp_stm
+      clock_timestamp(),                                           -- action_tstamp_clk
+      txid_current(),                                              -- transaction ID
+      current_setting('application_name'),                         -- client application
+      inet_client_addr(),                                          -- client_addr
+      inet_client_port(),                                          -- client_port
+      current_query(),                                             -- top-level query or queries (if multistatement) from client
+      substring(TG_OP,1,1),                                        -- action
+      NULL, NULL, NULL,                                            -- row_id, row_data, changed_fields
+      'f'                                                          -- statement_only
+    );
+
+    IF NOT TG_ARGV[0]::boolean IS DISTINCT FROM 'f'::boolean THEN
+      audit_row.client_query = NULL;
+    END IF;
+
+    IF ((TG_LEVEL = 'ROW') AND (TG_ARGV[1] IS NOT NULL) AND (TG_ARGV[1]::TEXT <> 'NULL') AND (TG_ARGV[1]::TEXT <> 'null') AND (TG_ARGV[1]::TEXT <> '')) THEN
+      pk_val_query = 'SELECT $1.' || quote_ident(TG_ARGV[1]::text);
+
+      IF (TG_OP IS DISTINCT FROM 'DELETE') THEN
+        EXECUTE pk_val_query INTO audit_row.row_id USING NEW;
+      END IF;
+
+      IF audit_row.row_id IS NULL THEN
+        EXECUTE pk_val_query INTO audit_row.row_id USING OLD;
+      END IF;
+    END IF;
+
+    IF TG_ARGV[2] IS NOT NULL THEN
+      excluded_cols = TG_ARGV[2]::text[];
+    END IF;
+
+    CREATE TEMP TABLE IF NOT EXISTS
+      "_app_user" (user_id integer, user_type text, ip_address inet);
+
+    IF (TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW') THEN
+      audit_row.row_data = hstore(OLD.*) - excluded_cols;
+      audit_row.changed_fields =  (hstore(NEW.*) - audit_row.row_data) - excluded_cols;
+      IF audit_row.changed_fields = hstore('') THEN
+        -- All changed fields are ignored. Skip this update.
+        RETURN NULL;
+      END IF;
+    ELSIF (TG_OP = 'DELETE' AND TG_LEVEL = 'ROW') THEN
+      audit_row.row_data = hstore(OLD.*) - excluded_cols;
+    ELSIF (TG_OP = 'INSERT' AND TG_LEVEL = 'ROW') THEN
+      audit_row.row_data = hstore(NEW.*) - excluded_cols;
+    ELSIF (TG_LEVEL = 'STATEMENT' AND TG_OP IN ('INSERT','UPDATE','DELETE','TRUNCATE')) THEN
+      audit_row.statement_only = 't';
+    ELSE
+      RAISE EXCEPTION '[SELECTED_SCHEMA_NAME.if_modified_func] - Trigger func added as trigger for unhandled case: %, %',TG_OP, TG_LEVEL;
+      RETURN NULL;
+    END IF;
+
+    -- inject app_user data into audit
+    BEGIN
+      PERFORM
+      n.nspname, c.relname
+      FROM
+      pg_catalog.pg_class c
+      LEFT JOIN
+      pg_catalog.pg_namespace n
+      ON n.oid = c.relnamespace
+      WHERE
+      n.nspname like 'pg_temp_%'
+      AND
+      c.relname = '_app_user';
+
+      IF FOUND THEN
+      FOR user_row IN SELECT * FROM _app_user LIMIT 1 LOOP
+        audit_row.app_user_id = user_row.user_id;
+        audit_row.app_user_type = user_row.user_type;
+        audit_row.app_ip_address = user_row.ip_address;
+      END LOOP;
+      END IF;
+    END;
+    -- end app_user data
+
+    INSERT INTO SELECTED_SCHEMA_NAME.logged_actions_view VALUES (audit_row.*);
+    RETURN NULL;
+  END;
+$$
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = pg_catalog, public;
+
+
+COMMENT ON FUNCTION SELECTED_SCHEMA_NAME.if_modified_func() IS
+$$
+  Track changes to a table at the statement and/or row level.
+
+  Optional parameters to trigger in CREATE TRIGGER call:
+
+  param 0: boolean, whether to log the query text. Default 't'.
+
+  param 1: text, primary_key_column of audited table if bigint.
+
+  param 2: text[], columns to ignore in updates. Default [].
+
+       Updates to ignored cols are omitted from changed_fields.
+
+       Updates with only ignored cols changed are not inserted
+       into the audit log.
+
+       Almost all the processing work is still done for updates
+       that ignored. If you need to save the load, you need to use
+       WHEN clause on the trigger instead.
+
+       No warning or error is issued if ignored_cols contains columns
+       that do not exist in the target table. This lets you specify
+       a standard set of ignored columns.
+
+  There is no parameter to disable logging of values. Add this trigger as
+  a 'FOR EACH STATEMENT' rather than 'FOR EACH ROW' trigger if you do not
+  want to log row values.
+
+  Note that the user name logged is the login role for the session. The audit trigger
+  cannot obtain the active role because it is reset by the SECURITY DEFINER invocation
+  of the audit trigger its self.
+$$;
+
+CREATE OR REPLACE FUNCTION SELECTED_SCHEMA_NAME.audit_table(target_table regclass, audit_rows boolean, audit_query_text boolean, ignored_cols text[])
+RETURNS void AS
+$$
+  DECLARE
+    stm_targets text = 'INSERT OR UPDATE OR DELETE OR TRUNCATE';
+    table_info temp_table_info;
+    _full_name regclass;
+    _q_txt text;
+    _pk_column_name text;
+    _pk_column_snip text;
+    _ignored_cols_snip text = '';
+  BEGIN
+    table_info = SELECTED_SCHEMA_NAME.get_table_information(target_table);
+    _full_name = quote_ident(table_info.schema_name) || '.' || quote_ident(table_info.table_name);
+
+    EXECUTE 'DROP TRIGGER IF EXISTS audit_trigger_row ON ' || _full_name;
+    EXECUTE 'DROP TRIGGER IF EXISTS audit_trigger_stm ON ' || _full_name;
+
+
+    EXECUTE 'CREATE TABLE IF NOT EXISTS SELECTED_SCHEMA_NAME.logged_actions_' || quote_ident(table_info.table_name) || '(
+      CHECK (table_name = ' || quote_literal(table_info.table_name) || '),
+      LIKE SELECTED_SCHEMA_NAME.logged_actions INCLUDING ALL
+    ) INHERITS (SELECTED_SCHEMA_NAME.logged_actions)';
+
+    IF audit_rows THEN
+      _pk_column_name = SELECTED_SCHEMA_NAME.get_primary_key_column(_full_name::TEXT);
+
+      IF _pk_column_name IS NOT NULL THEN
+        _pk_column_snip = ', ' || quote_literal(_pk_column_name);
+      ELSE
+        _pk_column_snip = ', NULL';
+      END IF;
+
+      IF array_length(ignored_cols,1) > 0 THEN
+        _ignored_cols_snip = ', ' || quote_literal(ignored_cols);
+      END IF;
+      _q_txt = 'CREATE TRIGGER audit_trigger_row AFTER INSERT OR UPDATE OR DELETE ON ' ||
+          _full_name ||
+          ' FOR EACH ROW EXECUTE PROCEDURE SELECTED_SCHEMA_NAME.if_modified_func(' ||
+          quote_literal(audit_query_text) || _pk_column_snip || _ignored_cols_snip || ');';
+      RAISE NOTICE '%',_q_txt;
+      EXECUTE _q_txt;
+      stm_targets = 'TRUNCATE';
+    ELSE
+    END IF;
+
+    _q_txt = '' ||
+        'CREATE TRIGGER audit_trigger_stm AFTER ' || stm_targets ||
+        ' ON ' || _full_name ||
+        ' FOR EACH STATEMENT EXECUTE PROCEDURE ' ||
+        'SELECTED_SCHEMA_NAME.if_modified_func(' || quote_literal(audit_query_text) || ');';
+    RAISE NOTICE '%',_q_txt;
+    EXECUTE _q_txt;
+
+  END;
+$$
+LANGUAGE plpgsql;
+
+COMMENT ON FUNCTION SELECTED_SCHEMA_NAME.audit_table(regclass, boolean, boolean, text[]) IS
+$$
+  Add auditing support to a table.
+
+  Arguments:
+      target_table:   Table name, schema qualified if not on search_path
+      audit_rows:     Record each row change, or only audit at a statement level
+      audit_query_text: Record the text of the client query that triggered the audit event?
+      ignored_cols:   Columns to exclude from update diffs, ignore updates that change only ignored cols.
+$$;
+
+-- Pg doesn't allow variadic calls with 0 params, so provide a wrapper
+CREATE OR REPLACE FUNCTION SELECTED_SCHEMA_NAME.audit_table(target_table regclass, audit_rows boolean, audit_query_text boolean)
+RETURNS void AS
+$$
+  SELECT SELECTED_SCHEMA_NAME.audit_table($1, $2, $3, ARRAY[]::text[]);
+$$
+LANGUAGE SQL;
+
+-- And provide a convenience call wrapper for the simplest case
+-- of row-level logging with no excluded cols and query logging enabled.
+--
+CREATE OR REPLACE FUNCTION SELECTED_SCHEMA_NAME.audit_table(target_table regclass)
+RETURNS void AS
+$$
+  SELECT SELECTED_SCHEMA_NAME.audit_table($1, BOOLEAN 't', BOOLEAN 't');
+$$
+LANGUAGE SQL;
+
+COMMENT ON FUNCTION SELECTED_SCHEMA_NAME.audit_table(regclass) IS
+$$
+  Add auditing support to the given table. Row-level changes will be logged with full client query text. No cols are ignored.
+$$;

data/lib/better_record/migration.rb

@@ -27,8 +27,8 @@ module BetterRecord
         end
 
         d.down do
-          execute "DROP TRIGGER audit_trigger_row ON #{table_name};"
-          execute "DROP TRIGGER audit_trigger_stm ON #{table_name};"
+          execute "DROP TRIGGER IF EXISTS audit_trigger_row ON #{table_name};"
+          execute "DROP TRIGGER IF EXISTS audit_trigger_stm ON #{table_name};"
         end
       end
     end

data/lib/better_record/polymorphic_override.rb

@@ -23,7 +23,7 @@ module BetterRecord
           $!.message, $!.backtrace if debug
 
         if type_val == :table_name_without_schema
-          type_val = klass.table_name
+          type_val = klass.table_name.to_s.split('.').first
         else
           type_val = klass.polymorphic_name
         end
@@ -36,7 +36,7 @@ module BetterRecord
     end
 
     def self.all_types(klass)
-      keys = [ :polymorphic_name, :table_name ]
+      keys = [ :polymorphic_name, :full_table_name, :table_name_only, :table_name ]
       keys |= [BetterRecord.default_polymorphic_method] if BetterRecord.default_polymorphic_method.present?
       p "Polymorphic methods:", keys if debug
       values = []

data/lib/better_record/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BetterRecord
-  VERSION = '0.22.9'
+  VERSION = '0.23.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: better_record
 version: !ruby/object:Gem::Version
-  version: 0.22.9
+  version: 0.23.3
 platform: ruby
 authors:
 - Sampson Crowley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-02 00:00:00.000000000 Z
+date: 2019-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -275,11 +275,14 @@ files:
 - db/migrate/20190209033946_update_better_record_audit_functions.rb
 - db/migrate/20190209195134_audit_trigger_v3.rb
 - db/migrate/20190416215152_add_three_state_boolean_type.rb
+- db/migrate/20190823220215_audit_trigger_v4.rb
 - db/postgres-audit-trigger.psql
 - db/postgres-audit-v2-table.psql
 - db/postgres-audit-v2-trigger.psql
 - db/postgres-audit-v3-table.psql
 - db/postgres-audit-v3-trigger.psql
+- db/postgres-audit-v4-table.psql
+- db/postgres-audit-v4-trigger.psql
 - lib/better_record.rb
 - lib/better_record/batches.rb
 - lib/better_record/concerns/active_record_extensions/associations_extensions/association_extension.rb
@@ -357,7 +360,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Fix functions that are lacking in Active record to be compatible with multi-app