Merge pull request rails#47650 from nickborromeo/add-error-codes-to-warnings-ignore-list

Allow SQL Warnings to be ignored using error codes

Author: matthewd

activerecord/CHANGELOG.md

@@ -1,3 +1,18 @@
+*   Allow warning codes to be ignore when reporting SQL warnings.
+
+    Active Record config that can ignore warning codes
+
+    ```ruby
+    # Configure allowlist of warnings that should always be ignored
+    config.active_record.db_warnings_ignore = [
+      "1062", # MySQL Error 1062: Duplicate entry
+    ]
+    ```
+
+    This is supported for the MySQL and PostgreSQL adapters.
+
+    *Nick Borromeo*
+
 *   Introduce `:active_record_fixtures` lazy load hook.
 
     Hooks defined with this name will be run whenever `TestFixtures` is included

activerecord/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -1197,7 +1197,9 @@ def default_prepared_statements
         end
 
         def warning_ignored?(warning)
-          ActiveRecord.db_warnings_ignore.any? { |warning_matcher| warning.message.match?(warning_matcher) }
+          ActiveRecord.db_warnings_ignore.any? do |warning_matcher|
+            warning.message.match?(warning_matcher) || warning.code.to_s.match?(warning_matcher)
+          end
         end
     end
   end

activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb

@@ -326,55 +326,45 @@ def test_database_timezone_changes_synced_to_connection
   end
 
   def test_ignores_warnings_when_behaviour_ignore
-    ActiveRecord.db_warnings_action = :ignore
-
-    result = @conn.execute('SELECT 1 + "foo"')
-
-    assert_equal [1], result.to_a.first
-  ensure
-    ActiveRecord.db_warnings_action = @original_db_warnings_action
+    with_db_warnings_action(:ignore) do
+      result = @conn.execute('SELECT 1 + "foo"')
+      assert_equal [1], result.to_a.first
+    end
   end
 
   def test_logs_warnings_when_behaviour_log
-    ActiveRecord.db_warnings_action = :log
-
-    mysql_warning = "[ActiveRecord::SQLWarning] Truncated incorrect DOUBLE value: 'foo' (1292)"
+    with_db_warnings_action(:log) do
+      mysql_warning = "[ActiveRecord::SQLWarning] Truncated incorrect DOUBLE value: 'foo' (1292)"
 
-    assert_called_with(ActiveRecord::Base.logger, :warn, [mysql_warning]) do
-      @conn.execute('SELECT 1 + "foo"')
+      assert_called_with(ActiveRecord::Base.logger, :warn, [mysql_warning]) do
+        @conn.execute('SELECT 1 + "foo"')
+      end
     end
-  ensure
-    ActiveRecord.db_warnings_action = @original_db_warnings_action
   end
 
   def test_raises_warnings_when_behaviour_raise
-    ActiveRecord.db_warnings_action = :raise
-
-    assert_raises(ActiveRecord::SQLWarning) do
-      @conn.execute('SELECT 1 + "foo"')
+    with_db_warnings_action(:raise) do
+      assert_raises(ActiveRecord::SQLWarning) do
+        @conn.execute('SELECT 1 + "foo"')
+      end
     end
-  ensure
-    ActiveRecord.db_warnings_action = @original_db_warnings_action
   end
 
   def test_reports_when_behaviour_report
-    ActiveRecord.db_warnings_action = :report
-
-    error_reporter = ActiveSupport::ErrorReporter.new
-    subscriber = ActiveSupport::ErrorReporter::TestHelper::ErrorSubscriber.new
+    with_db_warnings_action(:report) do
+      error_reporter = ActiveSupport::ErrorReporter.new
+      subscriber = ActiveSupport::ErrorReporter::TestHelper::ErrorSubscriber.new
 
-    Rails.define_singleton_method(:error) { error_reporter }
-    Rails.error.subscribe(subscriber)
+      Rails.define_singleton_method(:error) { error_reporter }
+      Rails.error.subscribe(subscriber)
 
-    @conn.execute('SELECT 1 + "foo"')
+      @conn.execute('SELECT 1 + "foo"')
 
-    warning_event, * = subscriber.events.first
+      warning_event, * = subscriber.events.first
 
-    assert_kind_of ActiveRecord::SQLWarning, warning_event
-    assert_equal "Truncated incorrect DOUBLE value: 'foo'", warning_event.message
-  ensure
-    Rails.singleton_class.remove_method(:error)
-    ActiveRecord.db_warnings_action = @original_db_warnings_action
+      assert_kind_of ActiveRecord::SQLWarning, warning_event
+      assert_equal "Truncated incorrect DOUBLE value: 'foo'", warning_event.message
+    end
   end
 
   def test_warnings_behaviour_can_be_customized_with_a_proc
@@ -391,64 +381,68 @@ def test_warnings_behaviour_can_be_customized_with_a_proc
   end
 
   def test_allowlist_of_warnings_to_ignore
-    old_ignored_warnings = ActiveRecord.db_warnings_ignore
-    ActiveRecord.db_warnings_action = :raise
-    ActiveRecord.db_warnings_ignore = [/Truncated incorrect DOUBLE value/]
+    with_db_warnings_action(:raise, [/Truncated incorrect DOUBLE value/]) do
+      result = @conn.execute('SELECT 1 + "foo"')
 
-    result = @conn.execute('SELECT 1 + "foo"')
+      assert_equal [1], result.to_a.first
+    end
+  end
 
-    assert_equal [1], result.to_a.first
-  ensure
-    ActiveRecord.db_warnings_action = @original_db_warnings_action
-    ActiveRecord.db_warnings_ignore = old_ignored_warnings
+  def test_allowlist_of_warning_codes_to_ignore
+    with_db_warnings_action(:raise, ["1062"]) do
+      row_id = @conn.insert("INSERT INTO posts (title, body) VALUES('Title', 'Body')")
+      result = @conn.execute("INSERT IGNORE INTO posts (id, title, body) VALUES(#{row_id}, 'Title', 'Body')")
+
+      assert_nil result
+    end
   end
 
   def test_does_not_raise_note_level_warnings
-    ActiveRecord.db_warnings_action = :raise
-
-    result = @conn.execute("DROP TABLE IF EXISTS non_existent_table")
+    with_db_warnings_action(:raise) do
+      result = @conn.execute("DROP TABLE IF EXISTS non_existent_table")
 
-    assert_equal [], result.to_a
-  ensure
-    ActiveRecord.db_warnings_action = @original_db_warnings_action
+      assert_equal [], result.to_a
+    end
   end
 
   def test_warnings_do_not_change_returned_value_of_exec_update
     previous_logger = ActiveRecord::Base.logger
-    ActiveRecord::Base.logger = ActiveSupport::Logger.new(nil)
-    ActiveRecord.db_warnings_action = :log
-
-    # Mysql2 will raise an error when attempting to perform an update that warns if the sql_mode is set to strict
     old_sql_mode = @conn.query_value("SELECT @@SESSION.sql_mode")
-    @conn.execute("SET @@SESSION.sql_mode=''")
 
-    @conn.execute("INSERT INTO posts (title, body) VALUES('Title', 'Body')")
-    result = @conn.update("UPDATE posts SET title = 'Updated' WHERE id > (0+'foo') LIMIT 1")
+    with_db_warnings_action(:log) do
+      ActiveRecord::Base.logger = ActiveSupport::Logger.new(nil)
+
+      # Mysql2 will raise an error when attempting to perform an update that warns if the sql_mode is set to strict
+      @conn.execute("SET @@SESSION.sql_mode=''")
+
+      @conn.execute("INSERT INTO posts (title, body) VALUES('Title', 'Body')")
+      result = @conn.update("UPDATE posts SET title = 'Updated' WHERE id > (0+'foo') LIMIT 1")
 
-    assert_equal 1, result
+      assert_equal 1, result
+    end
   ensure
     @conn.execute("SET @@SESSION.sql_mode='#{old_sql_mode}'")
     ActiveRecord::Base.logger = previous_logger
-    ActiveRecord.db_warnings_action = @original_db_warnings_action
   end
 
   def test_warnings_do_not_change_returned_value_of_exec_delete
     previous_logger = ActiveRecord::Base.logger
-    ActiveRecord::Base.logger = ActiveSupport::Logger.new(nil)
-    ActiveRecord.db_warnings_action = :log
-
-    # Mysql2 will raise an error when attempting to perform a delete that warns if the sql_mode is set to strict
     old_sql_mode = @conn.query_value("SELECT @@SESSION.sql_mode")
-    @conn.execute("SET @@SESSION.sql_mode=''")
 
-    @conn.execute("INSERT INTO posts (title, body) VALUES('Title', 'Body')")
-    result = @conn.delete("DELETE FROM posts WHERE id > (0+'foo') LIMIT 1")
+    with_db_warnings_action(:log) do
+      ActiveRecord::Base.logger = ActiveSupport::Logger.new(nil)
+
+      # Mysql2 will raise an error when attempting to perform a delete that warns if the sql_mode is set to strict
+      @conn.execute("SET @@SESSION.sql_mode=''")
+
+      @conn.execute("INSERT INTO posts (title, body) VALUES('Title', 'Body')")
+      result = @conn.delete("DELETE FROM posts WHERE id > (0+'foo') LIMIT 1")
 
-    assert_equal 1, result
+      assert_equal 1, result
+    end
   ensure
     @conn.execute("SET @@SESSION.sql_mode='#{old_sql_mode}'")
     ActiveRecord::Base.logger = previous_logger
-    ActiveRecord.db_warnings_action = @original_db_warnings_action
   end
 
   private

activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb

@@ -589,6 +589,15 @@ def test_allowlist_of_warnings_to_ignore
         end
       end
 
+      def test_allowlist_of_warning_codes_to_ignore
+        with_example_table do
+          with_db_warnings_action(:raise, ["01000"]) do
+            result = @connection.execute("do $$ BEGIN RAISE WARNING 'PostgreSQL SQL warning'; END; $$")
+            assert_equal [], result.to_a
+          end
+        end
+      end
+
       def test_does_not_raise_notice_level_warnings
         with_db_warnings_action(:raise, [/PostgreSQL SQL warning/]) do
           result = @connection.execute("DROP TABLE IF EXISTS non_existent_table")
@@ -606,20 +615,6 @@ def connection_without_insert_returning
           db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
           ActiveRecord::Base.postgresql_connection(db_config.configuration_hash.merge(insert_returning: false))
         end
-
-        def with_db_warnings_action(action, warnings_to_ignore = [])
-          original_db_warnings_ignore = ActiveRecord.db_warnings_ignore
-
-          ActiveRecord.db_warnings_action = action
-          ActiveRecord.db_warnings_ignore = warnings_to_ignore
-          @connection.disconnect! # Disconnect from the db so that we reconfigure the connection
-
-          yield
-        ensure
-          ActiveRecord.db_warnings_action = @original_db_warnings_action
-          ActiveRecord.db_warnings_ignore = original_db_warnings_ignore
-          @connection.disconnect!
-        end
     end
   end
 end

activerecord/test/cases/test_case.rb

@@ -115,6 +115,21 @@ def with_automatic_scope_inversing(*reflections)
       end
     end
 
+    def with_db_warnings_action(action, warnings_to_ignore = [])
+      original_db_warnings_ignore = ActiveRecord.db_warnings_ignore
+
+      ActiveRecord.db_warnings_action = action
+      ActiveRecord.db_warnings_ignore = warnings_to_ignore
+
+      ActiveRecord::Base.connection.disconnect! # Disconnect from the db so that we reconfigure the connection
+
+      yield
+    ensure
+      ActiveRecord.db_warnings_action = @original_db_warnings_action
+      ActiveRecord.db_warnings_ignore = original_db_warnings_ignore
+      ActiveRecord::Base.connection.disconnect!
+    end
+
     def reset_callbacks(klass, kind)
       old_callbacks = {}
       old_callbacks[klass] = klass.send("_#{kind}_callbacks").dup

guides/source/configuring.md

@@ -1023,7 +1023,7 @@ Controls the action to be taken when a SQL query produces a warning. The followi
 
 #### `config.active_record.db_warnings_ignore`
 
-Specifies an allowlist of warnings that will be ignored, regardless of the configured `db_warnings_action`.
+Specifies an allowlist of warning codes and messages that will be ignored, regardless of the configured `db_warnings_action`.
 The default behavior is to report all warnings. Warnings to ignore can be specified as Strings or Regexps. For example:
 
   ```ruby
@@ -1032,6 +1032,7 @@ The default behavior is to report all warnings. Warnings to ignore can be specif
   config.active_record.db_warnings_ignore = [
     /Invalid utf8mb4 character string/,
     "An exact warning message",
+    "1062", # MySQL Error 1062: Duplicate entry
   ]
   ```