Support SQLCounter change to ignore "SCHEMA" and "TRANSACTION" log

Refer rails/rails#36153 and rails/rails#36202

Some of Oracle enhanced adapter unit tests get failed
because they depend on log output which is not logged since they are "SCHEMA".

To workaround these  failures overriding `ActiveRecord::LogSubscriber::IGNORE_PAYLOAD_NAMES`
in `spec/spec_helper.rb`, which causes these warnings.

```
$ bundle exec rspec
==> Loading config from ENV or use default
==> Running specs with MRI version 2.6.3
==> Effective ActiveRecord version 6.1.0.alpha
/home/yahonda/git/oracle-enhanced/spec/spec_helper.rb:112: warning: already initialized constant ActiveRecord::LogSubscriber::IGNORE_PAYLOAD_NAMES
/home/yahonda/git/rails/activerecord/lib/active_record/log_subscriber.rb:5: warning: previous definition of IGNORE_PAYLOAD_NAMES was here
```

Author: yahonda

lib/active_record/connection_adapters/oracle_enhanced/database_statements.rb

@@ -189,11 +189,11 @@ def exec_rollback_db_transaction #:nodoc:
         end
 
         def create_savepoint(name = current_savepoint_name) #:nodoc:
-          execute("SAVEPOINT #{name}")
+          execute("SAVEPOINT #{name}", "TRANSACTION")
         end
 
         def exec_rollback_to_savepoint(name = current_savepoint_name) #:nodoc:
-          execute("ROLLBACK TO #{name}")
+          execute("ROLLBACK TO #{name}", "TRANSACTION")
         end
 
         def release_savepoint(name = current_savepoint_name) #:nodoc:

lib/active_record/connection_adapters/oracle_enhanced/schema_dumper.rb

@@ -167,7 +167,7 @@ def default_primary_key?(column)
 
           def extract_expression_for_virtual_column(column)
             column_name = column.name
-            @connection.select_value(<<~SQL.squish, "Table comment", [bind_string("table_name", table_name.upcase), bind_string("column_name", column_name.upcase)]).inspect
+            @connection.select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name.upcase), bind_string("column_name", column_name.upcase)]).inspect
               select data_default from all_tab_columns
               where owner = SYS_CONTEXT('userenv', 'current_schema')
               and table_name = :table_name

lib/active_record/connection_adapters/oracle_enhanced/schema_statements.rb

@@ -11,7 +11,7 @@ module SchemaStatements
         # see: abstract/schema_statements.rb
 
         def tables #:nodoc:
-          select_values(<<~SQL.squish, "tables")
+          select_values(<<~SQL.squish, "SCHEMA")
             SELECT DECODE(table_name, UPPER(table_name), LOWER(table_name), table_name)
             FROM all_tables
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -43,7 +43,7 @@ def table_exists?(table_name)
             table_owner, table_name = default_owner, real_name
           end
 
-          select_values(<<~SQL.squish, "table exists", [bind_string("owner", table_owner), bind_string("table_name", table_name)]).any?
+          select_values(<<~SQL.squish, "SCHEMA", [bind_string("owner", table_owner), bind_string("table_name", table_name)]).any?
             SELECT owner, table_name
             FROM all_tables
             WHERE owner = :owner
@@ -59,20 +59,20 @@ def data_source_exists?(table_name)
         end
 
         def views # :nodoc:
-          select_values(<<~SQL.squish, "views")
+          select_values(<<~SQL.squish, "SCHEMA")
             SELECT LOWER(view_name) FROM all_views WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
         end
 
         def materialized_views #:nodoc:
-          select_values(<<~SQL.squish, "materialized views")
+          select_values(<<~SQL.squish, "SCHEMA")
             SELECT LOWER(mview_name) FROM all_mviews WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
         end
 
         # get synonyms for schema dump
         def synonyms
-          result = select_all(<<~SQL.squish, "synonyms")
+          result = select_all(<<~SQL.squish, "SCHEMA")
             SELECT synonym_name, table_owner, table_name
             FROM all_synonyms where owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
@@ -87,7 +87,7 @@ def indexes(table_name) #:nodoc:
           (_owner, table_name) = @connection.describe(table_name)
           default_tablespace_name = default_tablespace
 
-          result = select_all(<<~SQL.squish, "indexes", [bind_string("table_name", table_name)])
+          result = select_all(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
             SELECT LOWER(i.table_name) AS table_name, LOWER(i.index_name) AS index_name, i.uniqueness,
               i.index_type, i.ityp_owner, i.ityp_name, i.parameters,
               LOWER(i.tablespace_name) AS tablespace_name,
@@ -117,7 +117,7 @@ def indexes(table_name) #:nodoc:
               statement_parameters = nil
               if row["index_type"] == "DOMAIN" && row["ityp_owner"] == "CTXSYS" && row["ityp_name"] == "CONTEXT"
                 procedure_name = default_datastore_procedure(row["index_name"])
-                source = select_values(<<~SQL.squish, "procedure", [bind_string("procedure_name", procedure_name.upcase)]).join
+                source = select_values(<<~SQL.squish, "SCHEMA", [bind_string("procedure_name", procedure_name.upcase)]).join
                   SELECT text
                   FROM all_source
                   WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -366,7 +366,7 @@ def index_name(table_name, options) #:nodoc:
         # Will always query database and not index cache.
         def index_name_exists?(table_name, index_name)
           (_owner, table_name) = @connection.describe(table_name)
-          result = select_value(<<~SQL.squish, "index name exists")
+          result = select_value(<<~SQL.squish, "SCHEMA")
             SELECT 1 FROM all_indexes i
             WHERE i.owner = SYS_CONTEXT('userenv', 'current_schema')
                AND i.table_owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -499,8 +499,9 @@ def change_column_comment(table_name, column_name, comment_or_changes)
         end
 
         def table_comment(table_name) #:nodoc:
+          # TODO
           (_owner, table_name) = @connection.describe(table_name)
-          select_value(<<~SQL.squish, "Table comment", [bind_string("table_name", table_name)])
+          select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
             SELECT comments FROM all_tab_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
               AND table_name = :table_name
@@ -516,7 +517,7 @@ def table_options(table_name) # :nodoc:
         def column_comment(table_name, column_name) #:nodoc:
           # TODO: it  does not exist in Abstract adapter
           (_owner, table_name) = @connection.describe(table_name)
-          select_value(<<~SQL.squish, "Column comment", [bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
+          select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
             SELECT comments FROM all_col_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
               AND table_name = :table_name
@@ -533,7 +534,7 @@ def type_to_sql(type, limit: nil, precision: nil, scale: nil, **) #:nodoc:
         end
 
         def tablespace(table_name)
-          select_value(<<~SQL.squish, "tablespace")
+          select_value(<<~SQL.squish, "SCHEMA")
             SELECT tablespace_name
             FROM all_tables
             WHERE table_name='#{table_name.to_s.upcase}'
@@ -545,7 +546,7 @@ def tablespace(table_name)
         def foreign_keys(table_name) #:nodoc:
           (_owner, desc_table_name) = @connection.describe(table_name)
 
-          fk_info = select_all(<<~SQL.squish, "Foreign Keys", [bind_string("desc_table_name", desc_table_name)])
+          fk_info = select_all(<<~SQL.squish, "SCHEMA", [bind_string("desc_table_name", desc_table_name)])
             SELECT r.table_name to_table
                   ,rc.column_name references_column
                   ,cc.column_name
@@ -587,7 +588,7 @@ def extract_foreign_key_action(specifier) # :nodoc:
         # REFERENTIAL INTEGRITY ====================================
 
         def disable_referential_integrity(&block) #:nodoc:
-          old_constraints = select_all(<<~SQL.squish, "Foreign Keys to disable and enable")
+          old_constraints = select_all(<<~SQL.squish, "SCHEMA")
             SELECT constraint_name, owner, table_name
               FROM all_constraints
               WHERE constraint_type = 'R'

lib/active_record/connection_adapters/oracle_enhanced/structure_dump.rb

@@ -8,7 +8,7 @@ module StructureDump #:nodoc:
         STATEMENT_TOKEN = "\n\n/\n\n"
 
         def structure_dump #:nodoc:
-          sequences = select(<<~SQL.squish, "sequences to dump at structure dump")
+          sequences = select(<<~SQL.squish, "SCHEMA")
             SELECT sequence_name, min_value, max_value, increment_by, order_flag, cycle_flag
             FROM all_sequences
             where sequence_owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1
@@ -17,7 +17,7 @@ def structure_dump #:nodoc:
           structure = sequences.map do |result|
             "CREATE SEQUENCE #{quote_table_name(result["sequence_name"])} MINVALUE #{result["min_value"]} MAXVALUE #{result["max_value"]} INCREMENT BY #{result["increment_by"]} #{result["order_flag"] == 'Y' ? "ORDER" : "NOORDER"} #{result["cycle_flag"] == 'Y' ? "CYCLE" : "NOCYCLE"}"
           end
-          tables = select_values(<<~SQL.squish, "tables at structure dump")
+          tables = select_values(<<~SQL.squish, "SCHEMA")
             SELECT table_name FROM all_tables t
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema') AND secondary = 'N'
             AND NOT EXISTS (SELECT mv.mview_name FROM all_mviews mv
@@ -29,7 +29,7 @@ def structure_dump #:nodoc:
           tables.each do |table_name|
             virtual_columns = virtual_columns_for(table_name) if supports_virtual_columns?
             ddl = +"CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n"
-            columns = select_all(<<~SQL.squish, "columns at structure dump")
+            columns = select_all(<<~SQL.squish, "SCHEMA")
               SELECT column_name, data_type, data_length, char_used, char_length,
               data_precision, data_scale, data_default, nullable
               FROM all_tab_columns
@@ -89,7 +89,7 @@ def structure_dump_virtual_column(column, data_default) #:nodoc:
 
         def structure_dump_primary_key(table) #:nodoc:
           opts = { name: "", cols: [] }
-          pks = select_all(<<~SQL.squish, "Primary Keys")
+          pks = select_all(<<~SQL.squish, "SCHEMA")
             SELECT a.constraint_name, a.column_name, a.position
               FROM all_cons_columns a
               JOIN all_constraints c
@@ -108,7 +108,7 @@ def structure_dump_primary_key(table) #:nodoc:
 
         def structure_dump_unique_keys(table) #:nodoc:
           keys = {}
-          uks = select_all(<<~SQL.squish, "Primary Keys")
+          uks = select_all(<<~SQL.squish, "SCHEMA")
             SELECT a.constraint_name, a.column_name, a.position
               FROM all_cons_columns a
               JOIN all_constraints c
@@ -144,7 +144,7 @@ def structure_dump_indexes(table_name) #:nodoc:
         end
 
         def structure_dump_fk_constraints #:nodoc:
-          foreign_keys = select_all(<<~SQL.squish, "foreign keys at structure dump")
+          foreign_keys = select_all(<<~SQL.squish, "SCHEMA")
             SELECT table_name FROM all_tables
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1
           SQL
@@ -172,7 +172,7 @@ def structure_dump_table_comments(table_name)
 
         def structure_dump_column_comments(table_name)
           comments = []
-          columns = select_values(<<~SQL.squish, "column comments at structure dump")
+          columns = select_values(<<~SQL.squish, "SCHEMA")
             SELECT column_name FROM user_tab_columns
             WHERE table_name = '#{table_name}' ORDER BY column_id
           SQL
@@ -206,7 +206,7 @@ def foreign_key_definition(to_table, options = {}) #:nodoc:
         # Extract all stored procedures, packages, synonyms.
         def structure_dump_db_stored_code #:nodoc:
           structure = []
-          all_source = select_all(<<~SQL.squish, "stored program at structure dump")
+          all_source = select_all(<<~SQL.squish, "SCHEMA")
             SELECT DISTINCT name, type
             FROM all_source
             WHERE type IN ('PROCEDURE', 'PACKAGE', 'PACKAGE BODY', 'FUNCTION', 'TRIGGER', 'TYPE')
@@ -238,7 +238,7 @@ def structure_dump_db_stored_code #:nodoc:
 
         def structure_dump_views #:nodoc:
           structure = []
-          views = select_all(<<~SQL.squish, "views at structure dump")
+          views = select_all(<<~SQL.squish, "SCHEMA")
             SELECT view_name, text FROM all_views
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY view_name ASC
           SQL
@@ -250,7 +250,7 @@ def structure_dump_views #:nodoc:
 
         def structure_dump_synonyms #:nodoc:
           structure = []
-          synonyms = select_all(<<~SQL.squish, "synonyms at structure dump")
+          synonyms = select_all(<<~SQL.squish, "SCHEMA")
             SELECT owner, synonym_name, table_name, table_owner
             FROM all_synonyms
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -263,13 +263,13 @@ def structure_dump_synonyms #:nodoc:
         end
 
         def structure_drop #:nodoc:
-          sequences = select_values(<<~SQL.squish, "sequences to drop at structure dump")
+          sequences = select_values(<<~SQL.squish, "SCHEMA")
             SELECT sequence_name FROM all_sequences where sequence_owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1
           SQL
           statements = sequences.map do |seq|
             "DROP SEQUENCE \"#{seq}\""
           end
-          tables = select_values(<<~SQL.squish, "tables to drop at structure dump")
+          tables = select_values(<<~SQL.squish, "SCHEMA")
             SELECT table_name from all_tables t
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema') AND secondary = 'N'
             AND NOT EXISTS (SELECT mv.mview_name FROM all_mviews mv
@@ -285,7 +285,7 @@ def structure_drop #:nodoc:
         end
 
         def temp_table_drop #:nodoc:
-          temporary_tables = select_values(<<~SQL.squish, "temporary tables to drop at structure dump")
+          temporary_tables = select_values(<<~SQL.squish, "SCHEMA")
             SELECT table_name FROM all_tables
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
             AND secondary = 'N' AND temporary = 'Y' ORDER BY 1
@@ -319,7 +319,7 @@ def execute_structure_dump(string)
         # Called only if `supports_virtual_columns?` returns true
         # return [{'column_name' => 'FOOS', 'data_default' => '...'}, ...]
         def virtual_columns_for(table)
-          select_all(<<~SQL.squish, "virtual columns for")
+          select_all(<<~SQL.squish, "SCHEMA")
             SELECT column_name, data_default
             FROM all_tab_cols
             WHERE virtual_column = 'YES'
@@ -330,7 +330,7 @@ def virtual_columns_for(table)
 
         def drop_sql_for_feature(type)
           short_type = type == "materialized view" ? "mview" : type
-          features = select_values(<<~SQL.squish, "features to drop")
+          features = select_values(<<~SQL.squish, "SCHEMA")
             SELECT #{short_type}_name FROM all_#{short_type.tableize}
             where owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
@@ -341,7 +341,7 @@ def drop_sql_for_feature(type)
         end
 
         def drop_sql_for_object(type)
-          objects = select_values(<<~SQL.squish, "objects to drop")
+          objects = select_values(<<~SQL.squish, "SCHEMA")
             SELECT object_name FROM all_objects
             WHERE object_type = '#{type.upcase}' and owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL

lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -463,7 +463,7 @@ def next_sequence_value(sequence_name)
         # if sequence_name is set to :autogenerated then it means that primary key will be populated by trigger
         raise ArgumentError "Trigger based primary key is not supported" if sequence_name == AUTOGENERATED_SEQUENCE_NAME
         # call directly connection method to avoid prepared statement which causes fetching of next sequence value twice
-        select_value(<<~SQL.squish, "next sequence value")
+        select_value(<<~SQL.squish, "SCHEMA")
           SELECT #{quote_table_name(sequence_name)}.NEXTVAL FROM dual
         SQL
       end
@@ -501,7 +501,7 @@ def reset_pk_sequence!(table_name, primary_key = nil, sequence_name = nil) #:nod
         end
 
         if primary_key && sequence_name
-          new_start_value = select_value(<<~SQL.squish, "new start value")
+          new_start_value = select_value(<<~SQL.squish, "SCHEMA")
             select NVL(max(#{quote_column_name(primary_key)}),0) + 1 from #{quote_table_name(table_name)}
           SQL
 
@@ -512,32 +512,32 @@ def reset_pk_sequence!(table_name, primary_key = nil, sequence_name = nil) #:nod
 
       # Current database name
       def current_database
-        select_value(<<~SQL.squish, "current database on CDB ")
+        select_value(<<~SQL.squish, "SCHEMA")
           SELECT SYS_CONTEXT('userenv', 'con_name') FROM dual
         SQL
       rescue ActiveRecord::StatementInvalid
-        select_value(<<~SQL.squish, "current database")
+        select_value(<<~SQL.squish, "SCHEMA")
           SELECT SYS_CONTEXT('userenv', 'db_name') FROM dual
         SQL
       end
 
       # Current database session user
       def current_user
-        select_value(<<~SQL.squish, "current user")
+        select_value(<<~SQL.squish, "SCHEMA")
           SELECT SYS_CONTEXT('userenv', 'session_user') FROM dual
         SQL
       end
 
       # Current database session schema
       def current_schema
-        select_value(<<~SQL.squish, "current schema")
+        select_value(<<~SQL.squish, "SCHEMA")
           SELECT SYS_CONTEXT('userenv', 'current_schema') FROM dual
         SQL
       end
 
       # Default tablespace name of current user
       def default_tablespace
-        select_value(<<~SQL.squish, "default tablespace")
+        select_value(<<~SQL.squish, "SCHEMA")
           SELECT LOWER(default_tablespace) FROM user_users
           WHERE username = SYS_CONTEXT('userenv', 'current_schema')
         SQL
@@ -546,7 +546,7 @@ def default_tablespace
       def column_definitions(table_name)
         (owner, desc_table_name) = @connection.describe(table_name)
 
-        select_all(<<~SQL.squish, "Column definitions")
+        select_all(<<~SQL.squish, "SCHEMA")
           SELECT cols.column_name AS name, cols.data_type AS sql_type,
                  cols.data_default, cols.nullable, cols.virtual_column, cols.hidden_column,
                  cols.data_type_owner AS sql_type_owner,
@@ -578,15 +578,15 @@ def clear_table_columns_cache(table_name)
       def pk_and_sequence_for(table_name, owner = nil, desc_table_name = nil) #:nodoc:
         (owner, desc_table_name) = @connection.describe(table_name)
 
-        seqs = select_values(<<~SQL.squish, "Sequence")
+        seqs = select_values(<<~SQL.squish, "SCHEMA")
           select us.sequence_name
           from all_sequences us
           where us.sequence_owner = '#{owner}'
           and us.sequence_name = upper(#{quote(default_sequence_name(desc_table_name))})
         SQL
 
         # changed back from user_constraints to all_constraints for consistency
-        pks = select_values(<<~SQL.squish, "Primary Key")
+        pks = select_values(<<~SQL.squish, "SCHEMA")
           SELECT cc.column_name
             FROM all_constraints c, all_cons_columns cc
            WHERE c.owner = '#{owner}'
@@ -620,7 +620,7 @@ def has_primary_key?(table_name, owner = nil, desc_table_name = nil) #:nodoc:
       def primary_keys(table_name) # :nodoc:
         (_owner, desc_table_name) = @connection.describe(table_name)
 
-        pks = select_values(<<~SQL.squish, "Primary Keys", [bind_string("table_name", desc_table_name)])
+        pks = select_values(<<~SQL.squish, "SCHEMA", [bind_string("table_name", desc_table_name)])
           SELECT cc.column_name
             FROM all_constraints c, all_cons_columns cc
            WHERE c.owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -650,7 +650,7 @@ def columns_for_distinct(columns, orders) #:nodoc:
       end
 
       def temporary_table?(table_name) #:nodoc:
-        select_value(<<~SQL.squish, "temporary table", [bind_string("table_name", table_name.upcase)]) == "Y"
+        select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name.upcase)]) == "Y"
           SELECT temporary FROM all_tables WHERE table_name = :table_name and owner = SYS_CONTEXT('userenv', 'current_schema')
         SQL
       end