[FIX] util/records: deduplicate before batch update

When updating record references we need to dedup uniq indexes. In the
case of inderect references the case when two old references become the
same new reference was missing.

Example to trigger the issue
```
test_15=> select * from mail_followers where res_model='res.partner.bank'
+----+------------------+--------+------------+
| id | res_model        | res_id | partner_id |
|----+------------------+--------+------------|
| 5  | res.partner.bank | 2      | 3          |
| 7  | res.partner.bank | 3      | 3          |
+----+------------------+--------+------------+
test_15=> select id,sanitized_acc_number,partner_id,company_id from res_partner_bank
+----+----------------------+------------+------------+
| id | sanitized_acc_number | partner_id | company_id |
|----+----------------------+------------+------------|
| 1  | 1                    | 3          | 1          |
| 2  | 1                    | 3          | 2          |
| 3  | 1                    | 3          | 3          |
+----+----------------------+------------+------------+
```

In such case the record replacer will replace references to the partner
bank as in the mapping `{2:1, 3:1}`. But this causes an error
```
2025-03-07 17:12:12,145 502959 ERROR test_15_16 odoo.sql_db: bad query:

            UPDATE "mail_followers" t
               SET "res_model" = 'res.partner.bank'
                   , "res_id" = _upgrade_rrr.new
              FROM _upgrade_rrr
             WHERE "res_model"='res.partner.bank'
               AND _upgrade_rrr.old = res_id

                    AND
                        NOT EXISTS(SELECT 1 FROM mail_followers WHERE "res_model" = 'res.partner.bank' AND "res_id" = _upgrade_rrr.new AND "partner_id"=t."partner_id")
                    ;
                DELETE FROM mail_followers USING _upgrade_rrr WHERE "res_model"='res.partner.bank' AND res_id = _upgrade_rrr.old;

ERROR: duplicate key value violates unique constraint "mail_followers_mail_followers_res_partner_res_model_id_uniq"
DETAIL:  Key (res_model, res_id, partner_id)=(res.partner.bank, 1, 3) already exists.
```

Author: aj-fuentes

src/util/records.py

@@ -1694,34 +1694,56 @@ def replace_record_references_batch(cr, id_mapping, model_src, model_dst=None, r
         if unique_indexes:
             conditions = []
             for _, uniq_cols in unique_indexes:
-                uniq_cols = set(uniq_cols) - {ir.res_id, ir.res_model, ir.res_model_id}  # noqa: PLW2901
+                uniq_cols = set(uniq_cols) - {ir.res_model, ir.res_model_id}  # noqa: PLW2901
+                if not uniq_cols:
+                    continue
                 conditions.append(
                     format_query(
                         cr,
-                        "NOT EXISTS(SELECT 1 FROM {table} WHERE {res_model_whr} AND {jmap_expr} AND {where_clause})",
-                        table=ir.table,
-                        res_model_whr=res_model_whr,
-                        jmap_expr=jmap_expr,
-                        where_clause=SQLStr(" AND ".join(format_query(cr, "{0}=t.{0}", col) for col in uniq_cols))
-                        if uniq_cols
-                        else SQLStr("True"),
+                        "(ROW_NUMBER() OVER(PARTITION BY {cols} ORDER BY t.id)) > 1",
+                        cols=SQLStr(
+                            ", ".join(
+                                "_upgrade_rrr.new" if col == ir.res_id else format_query(cr, "t.{0}", col)
+                                for col in uniq_cols
+                            )
+                        ),
                     )
                 )
-            query = format_query(
+            dedup_query = format_query(
                 cr,
-                """{prev_query}   AND {cond};
-
-            DELETE FROM {table} USING _upgrade_rrr WHERE {whr} AND {res_id} = _upgrade_rrr.old;
+                """
+                WITH dedup AS (
+                    SELECT t.id,
+                           {is_dup} is_dup
+                      FROM {table} t
+                      JOIN _upgrade_rrr
+                        ON _upgrade_rrr.old = t.{res_id}
+                       AND {model_match}
+                )
+                DELETE FROM {table} t
+                      USING dedup
+                      WHERE dedup.id = t.id
+                        AND dedup.is_dup
+                """,
+                model_match=ir.model_filter(placeholder="%(model_src)s", prefix="t."),
+                table=ir.table,
+                is_dup=SQLStr("\nOR ".join(conditions)),
+                res_id=ir.res_id,
+            )
+            cleanup_query = format_query(
+                cr,
+                """
+                DELETE FROM {table} t USING _upgrade_rrr WHERE {whr} AND {res_id} = _upgrade_rrr.old;
                 """,
-                prev_query=query,
-                cond=SQLStr("\nAND ".join(conditions)),
                 table=ir.table,
                 whr=whr,
                 res_id=ir.res_id,
             )
-            cr.execute(query, {"model_dst": model_dst, "model_src": model_src})
+            cr.execute(dedup_query, locals())
+            cr.execute(query, locals())
+            cr.execute(cleanup_query, locals())
         else:
-            fmt_query = cr.mogrify(query.format(**locals()), locals()).decode()
+            fmt_query = cr.mogrify(query, locals()).decode()
             parallel_execute(cr, explode_query_range(cr, fmt_query, table=ir.table, alias="t"))
 
     # reference fields