[FIX] records: use temp table in replacing refs

For the jsonb company dependent indirect references when
replacing record refs, building the query using the
original id mapping input can generate a large query
based on the number of references being updated, leading
to a 'stack depth limit exceeded' error.

We can use the mapping saved in the temp table
_upgrade_rrr instead.

Author: jjmaksoud

src/base/tests/test_util.py

@@ -1364,6 +1364,49 @@ def test_replace_record_references_batch__uniqueness(self):
         [count] = self.env.cr.fetchone()
         self.assertEqual(count, 1)
 
+    @unittest.skipUnless(util.version_gte("18.0"), "Only work on Odoo >= 18")
+    def test_replace_record_references_batch__company_dependent(self):
+        partner_model = self.env["ir.model"].search([("model", "=", "res.partner")])
+        self.env["ir.model.fields"].create(
+            {
+                "name": "x_test_curr",
+                "ttype": "many2one",
+                "model_id": partner_model.id,
+                "relation": "res.currency",
+                "company_dependent": True,
+            }
+        )
+        c1 = self.env["res.currency"].create({"name": "RC1", "symbol": "RC1"})
+        c2 = self.env["res.currency"].create({"name": "RC2", "symbol": "RC2"})
+        c3 = self.env["res.currency"].create({"name": "RC3", "symbol": "RC3"})
+
+        p1 = self.env["res.partner"].create({"name": "Captain Jack"})
+        p2 = self.env["res.partner"].create({"name": "River Song"})
+
+        old = {p1.id: f'{{"1":{c1.id}, "2":{c2.id}, "3":null}}', p2.id: f'{{"1":{c1.id}, "2":{c2.id}, "3":{c3.id}}}'}
+        for id, value in old.items():
+            self.env.cr.execute(
+                """
+                UPDATE res_partner
+                  SET x_test_curr = %s
+                WHERE id = %s
+                """,
+                [value, id],
+            )
+        mapping = {
+            c1.id: c2.id,
+            c2.id: c3.id,
+            c3.id: c1.id,
+        }
+        util.replace_record_references_batch(self.env.cr, mapping, "res.currency")
+        new = {p1.id: {"1": c2.id, "2": c3.id, "3": None}, p2.id: {"1": c2.id, "2": c3.id, "3": c1.id}}
+        self.env.cr.execute("SELECT id, x_test_curr FROM res_partner WHERE id IN %s", [(p1.id, p2.id)])
+        for id, currencies in self.env.cr.fetchall():
+            expected = new[id]
+            self.assertEqual(len(currencies), len(expected))
+            for comp in currencies:
+                self.assertEqual(currencies[comp], expected[comp])
+
     def _prepare_test_delete_unused(self):
         def create_cat():
             name = f"test_{uuid.uuid4().hex}"

src/util/records.py

@@ -1600,30 +1600,30 @@ def replace_record_references_batch(cr, id_mapping, model_src, model_dst=None, r
                             ir.res_id,
                         ],
                     )
-                json_path = cr.mogrify(
-                    "$.* ? ({})".format(" || ".join(["@ == %s"] * len(id_mapping))),
-                    list(id_mapping),
-                ).decode()
-
-                query = cr.mogrify(
-                    format_query(
-                        cr,
-                        """
-                        UPDATE {table}
-                           SET {column} = (
-                                   SELECT jsonb_object_agg(key, COALESCE(((jsonb_object(%s::text[]))->>value)::int, value::int))
-                                   FROM jsonb_each_text({column})
-                               )
-                         WHERE {column} IS NOT NULL
-                           AND {column} @? {json_path}
-                        """,
-                        table=ir.table,
-                        column=ir.res_id,
-                        json_path=sql.Literal(json_path),
-                    ),
-                    [list(map(list, id_mapping.items()))],
-                ).decode()
-                explode_execute(cr, query, table=ir.table)
+                query = format_query(
+                    cr,
+                    """
+                     WITH _upg_cd AS (
+                         SELECT t.id,
+                                jsonb_object_agg(j.key, COALESCE(r.new, j.value::int)) as value
+                           FROM {table} t
+                           JOIN jsonb_each_text(t.{column}) j
+                             ON true
+                      LEFT JOIN _upgrade_rrr r
+                             ON r.old = j.value::integer
+                          WHERE {{parallel_filter}}
+                       GROUP BY t.id
+                         HAVING bool_or(r.new IS NOT NULL)
+                     )
+                     UPDATE {table} t
+                        SET {column} = u.value
+                       FROM _upg_cd u
+                      WHERE u.id = t.id
+                    """,
+                    table=ir.table,
+                    column=ir.res_id,
+                )
+                explode_execute(cr, query, table=ir.table, alias="t")
                 # ensure all new ids exist
                 cr.execute(
                     format_query(