[IMP] util/models: check m2m tables on model rename

When renaming a model we need to check m2m tables that may need to be
renamed as well. Otherwise the ORM will create a new table that would be
empty. If the data is handled directly in the scripts the ignore
parameter can be used to avoid warnings.

Notes:
* From Odoo 9 the column relation_table exists in ir_model_fields
* From Odoo 10 the name of m2m tables is given by the model names ordered alphabetically

Related: odoo/upgrade#7752

Author: aj-fuentes

src/util/models.py

@@ -15,19 +15,22 @@
 from .helpers import _ir_values_value, _validate_model, model_of_table, table_of_model
 from .indirect_references import indirect_references
 from .inherit import for_each_inherit, inherit_parents
-from .misc import _cached, chunks, log_progress
+from .misc import _cached, chunks, log_progress, version_gte
 from .pg import (
+    SQLStr,
     _get_unique_indexes_with,
     column_exists,
     column_type,
     column_updatable,
     explode_execute,
     explode_query_range,
     format_query,
+    get_columns,
     get_m2m_tables,
     get_value_or_en_translation,
     parallel_execute,
     table_exists,
+    target_of,
     view_exists,
 )
 
@@ -268,7 +271,102 @@ def _replace_model_in_computed_custom_fields(cr, source, target):
         )
 
 
-def rename_model(cr, old, new, rename_table=True):
+def _update_m2m_tables(cr, from_model, old_table, new_table, ignored_m2ms=()):
+    """
+    Update m2m table names and columns.
+
+    :param str from_model: model for which the underlying table changed
+    :param str old_table: former table of the model
+    :param str new_table: new table of the model
+    :param list(str) ignored_m2ms: explicit list of m2m tables to ignore
+
+    :meta private: exclude from online docs
+    """
+    if old_table == new_table or not version_gte("10.0"):
+        return
+    m2m_tables = {t for t in get_m2m_tables(cr, new_table) if t not in ignored_m2ms}
+    cr.execute(
+        """
+        SELECT relation_table,
+               ARRAY_AGG(id)
+          FROM ir_model_fields
+         WHERE ttype = 'many2many'
+           AND relation_table = ANY(%s)
+           AND (  model = %s
+               OR relation = %s)
+      GROUP BY relation_table
+      ORDER BY relation_table
+        """,
+        [list(m2m_tables), from_model, from_model],
+    )
+    for m2m_table, field_ids in cr.fetchall():
+        m = re.match(r"(\w+)_{0}_rel|{0}_(\w+)_rel".format(re.escape(old_table)), m2m_table)
+        if not m:
+            continue
+        new_m2m_table = "{}_{}_rel".format(*sorted([m.group(1) or m.group(2), new_table]))
+        # Due to the 63 chars limit in generated constraint names, for long table names the FK
+        # constraint is dropped when renaming the table. We need the constraint to correctly
+        # identify the FK targets. The FK constraints will be dropped and recreated below.
+        pg_rename_table(cr, m2m_table, new_m2m_table, remove_constraints=False)
+        m2m_tables.remove(m2m_table)
+        m2m_tables.add(new_m2m_table)
+        _logger.info("Renamed m2m table %s to %s", m2m_table, new_m2m_table)
+        cr.execute(
+            "UPDATE ir_model_fields SET relation_table = %s WHERE id IN %s",
+            [new_m2m_table, tuple(field_ids)],
+        )
+
+    # Use the full list of tables, some tables are created during the upgrade via create_m2m
+    # There may be no ir_model_fields entry referencing such tables yet
+    for m2m_table in sorted(m2m_tables):
+        for m2m_col in get_columns(cr, m2m_table).iter_unquoted():
+            col_info = target_of(cr, m2m_table, m2m_col)
+            if not col_info or col_info[0] != new_table or col_info[1] != "id":
+                continue
+            old_col, new_col = map("{}_id".format, [old_table, new_table])
+            if m2m_col != old_col:
+                _logger.warning(
+                    "Possibly missing rename: the column %s of m2m table %s references the table %s",
+                    m2m_col,
+                    m2m_table,
+                    new_table,
+                )
+                continue
+            old_constraint = col_info[2]
+            cr.execute(
+                """
+                SELECT c.confdeltype
+                  FROM pg_constraint c
+                  JOIN pg_class t
+                    ON c.conrelid = t.oid
+                 WHERE t.relname = %s
+                   AND c.conname = %s
+                """,
+                [m2m_table, old_constraint],
+            )
+            on_delete = cr.fetchone()[0][0]
+            query = format_query(
+                cr,
+                """
+                ALTER TABLE {m2m_table}
+              RENAME COLUMN {old_col} TO {new_col};
+
+                ALTER TABLE {m2m_table}
+            DROP CONSTRAINT {old_constraint},
+            ADD FOREIGN KEY ({new_col}) REFERENCES {new_table} (id) ON DELETE {del_action}
+                """,
+                m2m_table=m2m_table,
+                old_col=old_col,
+                new_col=new_col,
+                old_constraint=old_constraint,
+                new_table=new_table,
+                del_action=SQLStr("RESTRICT") if on_delete == "r" else SQLStr("CASCADE"),
+            )
+            cr.execute(query)
+            _logger.info("Renamed m2m column of table %s from %s to %s", m2m_table, old_col, new_col)
+
+
+def rename_model(cr, old, new, rename_table=True, ignored_m2ms=()):
     """
     Rename a model.
 
@@ -285,6 +383,7 @@ def rename_model(cr, old, new, rename_table=True):
         new_table = table_of_model(cr, new)
         if new_table != old_table:
             pg_rename_table(cr, old_table, new_table)
+            _update_m2m_tables(cr, old, old_table, new_table, ignored_m2ms)
 
     updates = [("wkf", "osv")] if table_exists(cr, "wkf") else []
     updates += [(ir.table, ir.res_model) for ir in indirect_references(cr) if ir.res_model]