[IMP] core: jsonb company dependent field

HydrionBurst · HydrionBurst · commit 3c2488e611eb · 2024-09-23T12:09:39.000Z
support jsonb company dependent field See odoo/odoo#175627 See odoo/enterprise#67925 See odoo/upgrade#6366 closes #124 Task: 3954610 Signed-off-by: Christophe Simonis (chs) <chs@odoo.com>
diff --git a/src/util/fields.py b/src/util/fields.py
@@ -506,7 +506,8 @@ def rename_field(cr, model, old, new, update_references=True, domain_adapter=Non
             # (before saas~11.2, where pattern changed)
             name = "%s_%s" % (name, fid)
             cr.execute("UPDATE ir_model_data SET name=%s WHERE model='ir.model.fields' AND res_id=%s", [name, fid])
-        cr.execute("UPDATE ir_property SET name=%s WHERE fields_id=%s", [new, fid])
+        if table_exists(cr, "ir_property"):
+            cr.execute("UPDATE ir_property SET name=%s WHERE fields_id=%s", [new, fid])
     # Updates custom field relation name to match the renamed standard field during upgrade.
     cr.execute(
         """
@@ -652,7 +653,66 @@ def convert_field_to_html(cr, model, field, skip_inherit=()):
         convert_field_to_html(cr, inh.model, field, skip_inherit=skip_inherit)
 
 
-def convert_field_to_property(
+def _convert_field_to_company_dependent(
+    cr, model, field, type, target_model=None, default_value=None, default_value_ref=None, company_field="company_id"
+):
+    _validate_model(model)
+    if target_model:
+        _validate_model(target_model)
+
+    type2field = {"char", "float", "boolean", "integer", "text", "many2one", "date", "datetime", "selection", "html"}
+    assert type in type2field
+
+    table = table_of_model(cr, model)
+
+    # update "ir_model_fields"."company_dependent" as an identifier for indirect reference
+    cr.execute(
+        """
+        UPDATE ir_model_fields
+           SET company_dependent = TRUE
+         WHERE model = %s
+           AND name = %s
+     RETURNING id
+        """,
+        (model, field),
+    )
+    if not cr.rowcount:
+        # no ir_model_fields, no column
+        remove_column(cr, table, field, cascade=True)
+        return
+    [field_id] = cr.fetchone()
+
+    if default_value is None:  # noqa: SIM108
+        where_condition = "{0} IS NOT NULL"
+    else:
+        where_condition = cr.mogrify("{0} != %s", [default_value]).decode()
+    where_condition += format_query(cr, " AND {} IS NOT NULL", company_field)
+
+    using = format_query(cr, "jsonb_build_object({}, {{0}})", company_field)
+    alter_column_type(cr, table, field, "jsonb", using=using, where=where_condition)
+
+    # delete all old default
+    cr.execute("DELETE FROM ir_default WHERE field_id = %s", [field_id])
+
+    # add fallback
+    if default_value:
+        cr.execute(
+            "INSERT INTO ir_default(field_id, json_value) VALUES (%s, %s) RETURNING id",
+            (field_id, json.dumps(default_value)),
+        )
+        [default_id] = cr.fetchone()
+        if default_value_ref:
+            module, _, xid = default_value_ref.partition(".")
+            cr.execute(
+                """
+                INSERT INTO ir_model_data(module, name, model, res_id, noupdate)
+                     VALUES (%s, %s, 'ir.default', %s, True)
+                """,
+                [module, xid, default_id],
+            )
+
+
+def _convert_field_to_property(
     cr, model, field, type, target_model=None, default_value=None, default_value_ref=None, company_field="company_id"
 ):
     """
@@ -777,7 +837,13 @@ def convert_field_to_property(
 
 
 # alias with a name related to the new API to declare property fields (company_dependent=True attribute)
-make_field_company_dependent = convert_field_to_property
+if version_gte("saas~17.5"):
+    make_field_company_dependent = _convert_field_to_company_dependent
+else:
+    make_field_company_dependent = _convert_field_to_property
+
+# retro-compatibility
+convert_field_to_property = make_field_company_dependent
 
 
 def convert_binary_field_to_attachment(cr, model, field, encoded=True, name_field=None):
diff --git a/src/util/indirect_references.py b/src/util/indirect_references.py
@@ -5,7 +5,11 @@
 from .pg import column_exists, table_exists
 
 
-class IndirectReference(collections.namedtuple("IndirectReference", "table res_model res_id res_model_id set_unknown")):
+class IndirectReference(
+    collections.namedtuple(
+        "IndirectReference", "table res_model res_id res_model_id set_unknown company_dependent_comodel"
+    )
+):
     def model_filter(self, prefix="", placeholder="%s"):
         if prefix and prefix[-1] != ".":
             prefix += "."
@@ -109,12 +113,25 @@ def indirect_references(cr, bound_only=False):
 
         yield ir
 
+    if column_exists(cr, "ir_model_fields", "company_dependent"):
+        cr.execute(
+            """
+            SELECT model, name, relation
+              FROM ir_model_fields
+             WHERE company_dependent IS TRUE
+               AND ttype = 'many2one'
+            """,
+        )
+        for table_name, column_name, comodel_name in cr.fetchall():
+            yield IR(table_name, None, column_name, company_dependent_comodel=comodel_name)
+
     # XXX Once we will get the model field of `many2one_reference` fields in the database, we should get them also
     # (and filter the one already hardcoded)
 
 
 def generate_indirect_reference_cleaning_queries(cr, ir):
     """Yield queries to clean an `IndirectReference`."""
+    assert not ir.company_dependent_comodel  # not supported for now
     if ir.res_model:
         query = """
             SELECT {ir.res_model}
diff --git a/src/util/models.py b/src/util/models.py
@@ -22,6 +22,7 @@
     column_updatable,
     explode_execute,
     explode_query_range,
+    format_query,
     get_m2m_tables,
     get_value_or_en_translation,
     parallel_execute,
@@ -76,6 +77,34 @@ def remove_model(cr, model, drop_table=True, ignore_m2m=()):
 
     # remove references
     for ir in indirect_references(cr):
+        if ir.company_dependent_comodel:
+            if ir.company_dependent_comodel == "ir.model":
+                # clean on delete set null
+                cr.execute("SELECT id FROM ir_model WHERE name = %s", [model])
+                [mod_id] = cr.fetchone() or [None]
+                if mod_id:
+                    cr.execute(
+                        format_query(
+                            """
+                            UPDATE {table}
+                               SET {field} = (
+                                   SELECT jsonb_object_agg(
+                                          key,
+                                          CASE
+                                              WHEN value::int4 = %s THEN NULL
+                                              ELSE value::int4
+                                          END)
+                                     FROM jsonb_each_text({field})
+                                   )
+                             WHERE {field} IS NOT NULL
+                               AND {field} @? %s
+                            """,
+                            table=ir.table,
+                            field=ir.res_id,
+                        ),
+                        [mod_id, "$.* ? (@ == {})".format(mod_id)],
+                    )
+            continue
         if ir.table in ("ir_model", "ir_model_fields", "ir_model_data"):
             continue
         ref_model = model_of_table(cr, ir.table)
diff --git a/src/util/pg.py b/src/util/pg.py
@@ -570,7 +570,7 @@ def remove_column(cr, table, column, cascade=False):
         cr.execute('ALTER TABLE "{0}" DROP COLUMN "{1}"{2}'.format(table, column, drop_cascade))
 
 
-def alter_column_type(cr, table, column, type, using=None, logger=_logger):
+def alter_column_type(cr, table, column, type, using=None, where=None, logger=_logger):
     # remove the existing linked `ir_model_fields_selection` recods in case it was a selection field
     if table_exists(cr, "ir_model_fields_selection"):
         cr.execute(
@@ -604,9 +604,13 @@ def alter_column_type(cr, table, column, type, using=None, logger=_logger):
     cr.execute(format_query(cr, "ALTER TABLE {} ADD COLUMN {} {}", table, column, sql.SQL(type)))
 
     using = sql.SQL(format_query(cr, using, tmp_column))
-    where_clause = sql.SQL("")
-    if column_type(cr, table, tmp_column) != "bool":
-        where_clause = sql.SQL(format_query(cr, "WHERE {} IS NOT NULL", tmp_column))
+    if where is None:
+        where_clause = sql.SQL("")
+        if column_type(cr, table, tmp_column) != "bool":
+            where_clause = sql.SQL(format_query(cr, "WHERE {} IS NOT NULL", tmp_column))
+    else:
+        where_clause = sql.SQL(format_query(cr, "WHERE " + where, tmp_column))
+
     explode_execute(
         cr,
         format_query(cr, "UPDATE {} SET {} = {} {}", table, column, using, where_clause),
diff --git a/src/util/records.py b/src/util/records.py
@@ -410,8 +410,34 @@ def remove_records(cr, model, ids):
     table = table_of_model(cr, model)
     cr.execute('DELETE FROM "{}" WHERE id IN %s'.format(table), [ids])
     for ir in indirect_references(cr, bound_only=True):
-        query = 'DELETE FROM "{}" WHERE {} AND "{}" IN %s'.format(ir.table, ir.model_filter(), ir.res_id)
-        cr.execute(query, [model, ids])
+        if not ir.company_dependent_comodel:
+            query = 'DELETE FROM "{}" WHERE {} AND "{}" IN %s'.format(ir.table, ir.model_filter(), ir.res_id)
+            cr.execute(query, [model, ids])
+        elif ir.company_dependent_comodel == model:
+            query = cr.mogrify(
+                format_query(
+                    cr,
+                    """
+                    UPDATE {table}
+                    SET {column} = (
+                        SELECT jsonb_object_agg(
+                            key,
+                            CASE
+                                WHEN value::int4 IN %s THEN NULL
+                                ELSE value::int4
+                            END)
+                        FROM jsonb_each_text({column})
+                    )
+                    WHERE {column} IS NOT NULL
+                    AND {column} @? %s
+                    AND {{parallel_filter}}
+                    """,
+                    table=ir.table,
+                    column=ir.res_id,
+                ),
+                [ids, "$.* ? ({})".format(" || ".join(map("@ == {}".format, ids)))],
+            ).decode()
+            explode_execute(cr, query, table=ir.table)
     _rm_refs(cr, model, ids)
 
     if model == "res.groups":
@@ -1440,6 +1466,29 @@ def replace_record_references_batch(cr, id_mapping, model_src, model_dst=None, r
     for ir in indirect_references(cr, bound_only=True):
         if ir.table in ignores:
             continue
+        if ir.company_dependent_comodel:
+            if ir.company_dependent_comodel == model_src:
+                assert model_src == model_dst
+                query = cr.mogrify(
+                    format_query(
+                        cr,
+                        """
+                        UPDATE {table}
+                           SET {column} = (
+                                   SELECT jsonb_object_agg(key, COALESCE((%s::jsonb->>value)::int, value::int))
+                                   FROM jsonb_each_text({column})
+                               )
+                         WHERE {column} IS NOT NULL
+                           AND {column} @? %s
+                           AND {{parallel_filter}}
+                        """,
+                        table=ir.table,
+                        column=ir.res_id,
+                    ),
+                    [Json(id_mapping), "$.* ? ({})".format(" || ".join(map("@ == {}".format, id_mapping)))],
+                ).decode()
+                explode_execute(cr, query, table=ir.table)
+            continue
         res_model_upd = []
         if ir.res_model:
             res_model_upd.append('"{ir.res_model}" = %(model_dst)s')
