Add opt-in INSERT IGNORE support for MySQL via conflict_target

mehiel · mehiel · commit 8c7955df9dae · 2025-12-16T11:41:15.000+02:00
The default on_conflict: :nothing behavior now uses the ON DUPLICATE KEY
UPDATE x = x workaround (restoring original behavior), which always reports
1 affected row regardless of whether the row was inserted or ignored.

For users who need accurate row counts (0 when ignored, 1 when inserted),
INSERT IGNORE can be explicitly enabled via:

    Repo.insert_all(Post, posts,
      on_conflict: :nothing,
      conflict_target: {:unsafe_fragment, "insert_ignore"})

This approach was chosen to avoid modifying Ecto core with a new on_conflict
type like :ignore for MySQL-specific intricacies. By leveraging the existing
{:unsafe_fragment, _} mechanism, MySQL users can opt into INSERT IGNORE
semantics when needed while maintaining backward compatibility.

Note that INSERT IGNORE has broader semantics in MySQL - it ignores certain
type conversion errors in addition to duplicate key conflicts - which is why
it's not the default behavior.
diff --git a/integration_test/myxql/upsert_all_test.exs b/integration_test/myxql/upsert_all_test.exs
@@ -13,60 +13,84 @@ defmodule Ecto.Integration.UpsertAllTest do
 
   test "on conflict ignore" do
     post = [title: "first", uuid: "6fa459ea-ee8a-3ca4-894e-db77e160355e"]
-    # First insert succeeds - 1 row inserted
+    # Default :nothing behavior uses ON DUPLICATE KEY UPDATE x = x workaround
+    # which always reports rows as affected
+    assert TestRepo.insert_all(Post, [post], on_conflict: :nothing) == {1, nil}
     assert TestRepo.insert_all(Post, [post], on_conflict: :nothing) == {1, nil}
+  end
+
+  test "explicit insert ignore" do
+    post = [title: "first", uuid: "6fa459ea-ee8a-3ca4-894e-db77e160355e"]
+    # First insert succeeds - 1 row inserted
+    assert TestRepo.insert_all(Post, [post],
+             on_conflict: :nothing,
+             conflict_target: {:unsafe_fragment, "insert_ignore"}
+           ) == {1, nil}
+
     # Second insert is ignored due to duplicate - 0 rows inserted (INSERT IGNORE behavior)
-    assert TestRepo.insert_all(Post, [post], on_conflict: :nothing) == {0, nil}
+    assert TestRepo.insert_all(Post, [post],
+             on_conflict: :nothing,
+             conflict_target: {:unsafe_fragment, "insert_ignore"}
+           ) == {0, nil}
   end
 
-  test "on conflict ignore with mixed records (some conflicts, some new)" do
+  test "explicit insert ignore with mixed records (some conflicts, some new)" do
     # Insert an existing post
     existing_uuid = "6fa459ea-ee8a-3ca4-894e-db77e160355e"
     existing_post = [title: "existing", uuid: existing_uuid]
-    assert TestRepo.insert_all(Post, [existing_post], on_conflict: :nothing) == {1, nil}
+
+    assert TestRepo.insert_all(Post, [existing_post],
+             on_conflict: :nothing,
+             conflict_target: {:unsafe_fragment, "insert_ignore"}
+           ) == {1, nil}
 
     # Now insert a batch with one duplicate and two new records
     new_uuid1 = "7fa459ea-ee8a-3ca4-894e-db77e160355f"
     new_uuid2 = "8fa459ea-ee8a-3ca4-894e-db77e160355a"
 
     posts = [
-      [title: "new post 1", uuid: new_uuid1],     # new - should be inserted
-      [title: "duplicate", uuid: existing_uuid],   # duplicate - should be ignored
-      [title: "new post 2", uuid: new_uuid2]       # new - should be inserted
+      [title: "new post 1", uuid: new_uuid1],
+      [title: "duplicate", uuid: existing_uuid],
+      [title: "new post 2", uuid: new_uuid2]
     ]
 
     # With INSERT IGNORE, only 2 rows should be inserted (the non-duplicates)
-    assert TestRepo.insert_all(Post, posts, on_conflict: :nothing) == {2, nil}
+    assert TestRepo.insert_all(Post, posts,
+             on_conflict: :nothing,
+             conflict_target: {:unsafe_fragment, "insert_ignore"}
+           ) == {2, nil}
 
     # Verify the data - should have 3 posts total (1 existing + 2 new)
     assert length(TestRepo.all(Post)) == 3
 
     # Verify the existing post was not modified
     [original] = TestRepo.all(from p in Post, where: p.uuid == ^existing_uuid)
-    assert original.title == "existing"  # title unchanged
+    assert original.title == "existing"
 
     # Verify new posts were inserted
     assert TestRepo.exists?(from p in Post, where: p.uuid == ^new_uuid1)
     assert TestRepo.exists?(from p in Post, where: p.uuid == ^new_uuid2)
   end
 
-  test "on conflict ignore with all duplicates" do
+  test "explicit insert ignore with all duplicates" do
     # Insert initial posts
     uuid1 = "1fa459ea-ee8a-3ca4-894e-db77e160355e"
     uuid2 = "2fa459ea-ee8a-3ca4-894e-db77e160355e"
-    initial_posts = [
-      [title: "first", uuid: uuid1],
-      [title: "second", uuid: uuid2]
-    ]
-    assert TestRepo.insert_all(Post, initial_posts, on_conflict: :nothing) == {2, nil}
+    initial_posts = [[title: "first", uuid: uuid1], [title: "second", uuid: uuid2]]
+
+    assert TestRepo.insert_all(Post, initial_posts,
+             on_conflict: :nothing,
+             conflict_target: {:unsafe_fragment, "insert_ignore"}
+           ) == {2, nil}
 
     # Try to insert all duplicates
-    duplicate_posts = [
-      [title: "dup1", uuid: uuid1],
-      [title: "dup2", uuid: uuid2]
-    ]
+    duplicate_posts = [[title: "dup1", uuid: uuid1], [title: "dup2", uuid: uuid2]]
+
     # All are duplicates, so 0 rows inserted
-    assert TestRepo.insert_all(Post, duplicate_posts, on_conflict: :nothing) == {0, nil}
+    assert TestRepo.insert_all(Post, duplicate_posts,
+             on_conflict: :nothing,
+             conflict_target: {:unsafe_fragment, "insert_ignore"}
+           ) == {0, nil}
 
     # Verify count unchanged
     assert length(TestRepo.all(Post)) == 2
diff --git a/lib/ecto/adapters/myxql.ex b/lib/ecto/adapters/myxql.ex
@@ -103,6 +103,23 @@ defmodule Ecto.Adapters.MyXQL do
   automatically commits after some commands like CREATE TABLE.
   Therefore MySQL migrations does not run inside transactions.
 
+  ### Upserts
+
+  When using `on_conflict: :nothing`, the adapter uses the
+  `ON DUPLICATE KEY UPDATE x = x` workaround to simulate "do nothing"
+  behavior. This always reports 1 affected row regardless of whether
+  the row was actually inserted or ignored.
+
+  If you need accurate row counts (0 when ignored, 1 when inserted),
+  you can opt into MySQL's `INSERT IGNORE` by specifying:
+
+      Repo.insert_all(Post, posts,
+        on_conflict: :nothing,
+        conflict_target: {:unsafe_fragment, "insert_ignore"})
+
+  Note that `INSERT IGNORE` has broader semantics in MySQL - it also
+  ignores certain type conversion errors, not just duplicate key conflicts.
+
   ## Old MySQL versions
 
   ### JSON support
@@ -330,10 +347,10 @@ defmodule Ecto.Adapters.MyXQL do
 
     case Ecto.Adapters.SQL.query(adapter_meta, sql, values ++ query_params, opts) do
       {:ok, %{num_rows: 0}} ->
-        # With INSERT IGNORE (on_conflict: :nothing), 0 rows means the row was
-        # ignored due to a conflict, which is expected behavior
+        # With INSERT IGNORE (explicit via conflict_target), 0 rows means the row
+        # was ignored due to a conflict, which is expected behavior
         case on_conflict do
-          {:nothing, _, _} ->
+          {:nothing, _, {:unsafe_fragment, "insert_ignore"}} ->
             {:ok, []}
 
           _ ->
diff --git a/lib/ecto/adapters/myxql/connection.ex b/lib/ecto/adapters/myxql/connection.ex
@@ -193,7 +193,10 @@ if Code.ensure_loaded?(MyXQL) do
       ]
     end
 
-    defp insert_keyword({:nothing, _, []}), do: "INSERT IGNORE INTO "
+    # INSERT IGNORE only when explicitly requested via conflict_target
+    defp insert_keyword({:nothing, _, {:unsafe_fragment, "insert_ignore"}}),
+      do: "INSERT IGNORE INTO "
+
     defp insert_keyword(_), do: "INSERT INTO "
 
     def insert(_prefix, _table, _header, _rows, _on_conflict, _returning, []) do
@@ -212,11 +215,17 @@ if Code.ensure_loaded?(MyXQL) do
       []
     end
 
-    defp on_conflict({:nothing, _, []}, _header) do
-      # Handled by INSERT IGNORE
+    # Explicit INSERT IGNORE - no ON DUPLICATE KEY clause needed
+    defp on_conflict({:nothing, _, {:unsafe_fragment, "insert_ignore"}}, _header) do
       []
     end
 
+    # Default :nothing - uses workaround to simulate "do nothing" behavior
+    defp on_conflict({:nothing, _, []}, [field | _]) do
+      quoted = quote_name(field)
+      [" ON DUPLICATE KEY UPDATE ", quoted, " = " | quoted]
+    end
+
     defp on_conflict({fields, _, []}, _header) when is_list(fields) do
       [
         " ON DUPLICATE KEY UPDATE "
diff --git a/test/ecto/adapters/myxql_test.exs b/test/ecto/adapters/myxql_test.exs
@@ -1465,10 +1465,12 @@ defmodule Ecto.Adapters.MyXQLTest do
     end
   end
 
-  test "insert with on conflict" do
-    # Using INSERT IGNORE for :nothing on_conflict
+  test "insert with on duplicate key" do
+    # Default :nothing uses ON DUPLICATE KEY UPDATE workaround
     query = insert(nil, "schema", [:x, :y], [[:x, :y]], {:nothing, [], []}, [])
-    assert query == ~s{INSERT IGNORE INTO `schema` (`x`,`y`) VALUES (?,?)}
+
+    assert query ==
+             ~s{INSERT INTO `schema` (`x`,`y`) VALUES (?,?) ON DUPLICATE KEY UPDATE `x` = `x`}
 
     update = from("schema", update: [set: [z: "foo"]]) |> plan(:update_all)
     query = insert(nil, "schema", [:x, :y], [[:x, :y]], {update, [], []}, [])
@@ -1498,6 +1500,21 @@ defmodule Ecto.Adapters.MyXQLTest do
                  end
   end
 
+  test "insert with explicit insert ignore" do
+    # Explicit INSERT IGNORE via conflict_target: {:unsafe_fragment, "insert_ignore"}
+    query =
+      insert(
+        nil,
+        "schema",
+        [:x, :y],
+        [[:x, :y]],
+        {:nothing, [], {:unsafe_fragment, "insert_ignore"}},
+        []
+      )
+
+    assert query == ~s{INSERT IGNORE INTO `schema` (`x`,`y`) VALUES (?,?)}
+  end
+
   test "insert with query" do
     select_query = from("schema", select: [:id]) |> plan(:all)
 
