Merge pull request #412 from ForgeFlow/master-imp-add_columns

[ADD] add_column: split from add_fields

Author: pedrobaeza

openupgradelib/openupgrade.py

@@ -163,6 +163,7 @@ def do_raise(error):
     "migrate",
     "logging",
     "load_data",
+    "add_columns",
     "add_fields",
     "copy_columns",
     "copy_fields_multilang",
@@ -191,6 +192,7 @@ def do_raise(error):
     "add_ir_model_fields",
     "get_legacy_name",
     "get_model2table",
+    "get_field2column_type",
     "m2o_to_x2m",
     "float_to_integer",
     "message",
@@ -1912,6 +1914,44 @@ def get_model2table(model):
     return model2table.get(model, model.replace(".", "_"))
 
 
+def get_field2column_type(field_type, translatable=False):
+    """This method returns SQL type given a field type.
+
+    :param: field type: binary, boolean, char, date, datetime, float, html,
+        integer, many2many, many2one, many2one_reference, monetary, one2many,
+        reference, selection, text, serialized. The list can vary depending on
+        Odoo version or custom added field types.
+    :param: (optional) translatable: From >=v16, if field is translatable then
+        SQL field type is changed to 'jsonb'.
+    :return: SQL field type: If the field type is custom or if it's one of the special
+        cases (see below), you need to indicate here the SQL type to use
+        (from the valid PostgreSQL types):
+        https://www.postgresql.org/docs/9.6/static/datatype.html"""
+    sql_type_mapping = {
+        "binary": "bytea",  # If there's attachment, no SQL. Force it manually
+        "boolean": "bool",
+        "char": "varchar",  # Force it manually if there's size limit
+        "date": "date",
+        "datetime": "timestamp",
+        "float": "numeric",  # Force manually to double precision if no digits
+        "html": "text",
+        "integer": "int4",
+        "many2many": False,  # No need to create SQL column
+        "many2one": "int4",
+        "many2one_reference": "int4",
+        "monetary": "numeric",
+        "one2many": False,  # No need to create SQL column
+        "reference": "varchar",
+        "selection": "varchar",  # Can be sometimes integer. Force it manually
+        "text": "text",
+        "serialized": "text",
+        "json": "jsonb",
+    }
+    if version_info[0] > 15 and field_type in ["char", "text", "html"] and translatable:
+        return "jsonb"
+    return sql_type_mapping.get(field_type, False)
+
+
 def m2o_to_x2m(cr, model, table, field, source_field):
     """
     Transform many2one relations into one2many or many2many.
@@ -2995,6 +3035,71 @@ def format_message(f):
             f.active = False
 
 
+def add_columns(env, field_spec):
+    """This method adds a new column.
+
+    It's intended for being run in pre-migration scripts for pre-populating
+    columns to avoid the execution of new stored computed fields.
+
+    :param: field_spec: List of tuples with the following expected elements
+      for each tuple:
+
+      * model name
+      * field name
+      * field type: binary, boolean, char, date, datetime, float, html,
+        integer, many2many, many2one, many2one_reference, monetary, one2many,
+        reference, selection, text, serialized. The list can vary depending on
+        Odoo version or custom added field types.
+      * (optional) initialization value: if included in the tuple, it is set
+        in the column for existing records.
+      * (optional) SQL table name
+      * (optional) SQL field type: If the field type is custom or if it's one
+        of the special cases (see get_field2column_type), you need to indicate
+        here the SQL type to use (from the valid PostgreSQL types):
+        https://www.postgresql.org/docs/9.6/static/datatype.html
+      * (optional) translatable: From >=v16, if field is translatable then
+        SQL field type is changed to 'jsonb'.
+    """
+    cr = env.cr
+    for vals in field_spec:
+        model_name = vals[0]
+        field_name = vals[1]
+        field_type = vals[2]
+        init_value = vals[3] if len(vals) > 3 else False
+        table_name = vals[4] if len(vals) > 4 else False
+        sql_type = vals[5] if len(vals) > 5 else False
+        translatable = vals[6] if len(vals) > 6 else False
+        sql_type = sql_type or get_field2column_type(field_type, translatable)
+        if version_info[0] > 15 and translatable:
+            from psycopg2.extras import Json
+
+            init_value = init_value and Json({"en_US": init_value})
+        if not table_name:
+            try:
+                table_name = env[model_name]._table
+            except KeyError:
+                table_name = get_model2table(model_name)
+        if sql_type and not column_exists(cr, table_name, field_name):
+            query = sql.SQL("ALTER TABLE {} ADD COLUMN {} {}").format(
+                sql.Identifier(table_name),
+                sql.Identifier(field_name),
+                sql.SQL(sql_type),
+            )
+            args = []
+            if init_value:
+                query += sql.SQL(" DEFAULT %s")
+                args.append(init_value)
+            logged_query(cr, query, args)
+            if init_value:
+                logged_query(
+                    cr,
+                    sql.SQL("ALTER TABLE {} ALTER COLUMN {} DROP DEFAULT").format(
+                        sql.Identifier(table_name),
+                        sql.Identifier(field_name),
+                    ),
+                )
+
+
 def add_fields(env, field_spec):
     """This method adds all the needed stuff for having a new field populated
     in the DB (SQL column, ir.model.fields entry, ir.model.data entry...).
@@ -3006,7 +3111,7 @@ def add_fields(env, field_spec):
     always add the XML-ID entry:
     https://github.com/odoo/odoo/blob/9201f92a4f29a53a014b462469f27b32dca8fc5a/
     odoo/addons/base/models/ir_model.py#L794-L802, but you can still call
-    this method for consistency and for avoiding to know the internal PG
+    this method for consistency and for avoiding knowing the internal PG
     column type.
 
     :param: field_spec: List of tuples with the following expected elements
@@ -3020,33 +3125,18 @@ def add_fields(env, field_spec):
         integer, many2many, many2one, many2one_reference, monetary, one2many,
         reference, selection, text, serialized. The list can vary depending on
         Odoo version or custom added field types.
-      * SQL field type: If the field type is custom or it's one of the special
-        cases (see below), you need to indicate here the SQL type to use
-        (from the valid PostgreSQL types):
+      * SQL field type: If the field type is custom or if it's one of the special
+        cases (see get_field2column_type), you need to indicate here the SQL type
+        to use (from the valid PostgreSQL types):
         https://www.postgresql.org/docs/9.6/static/datatype.html
+
+        Note: From >=v16, if field is translatable, SQL field type has to be
+        explicitly stated as 'jsonb'.
+
       * module name: for adding the XML-ID entry.
       * (optional) initialization value: if included in the tuple, it is set
         in the column for existing records.
     """
-    sql_type_mapping = {
-        "binary": "bytea",  # If there's attachment, no SQL. Force it manually
-        "boolean": "bool",
-        "char": "varchar",  # Force it manually if there's size limit
-        "date": "date",
-        "datetime": "timestamp",
-        "float": "numeric",  # Force manually to double precision if no digits
-        "html": "text",
-        "integer": "int4",
-        "many2many": False,  # No need to create SQL column
-        "many2one": "int4",
-        "many2one_reference": "int4",
-        "monetary": "numeric",
-        "one2many": False,  # No need to create SQL column
-        "reference": "varchar",
-        "selection": "varchar",  # Can be sometimes integer. Force it manually
-        "text": "text",
-        "serialized": "text",
-    }
     for vals in field_spec:
         field_name = vals[0]
         model_name = vals[1]
@@ -3055,33 +3145,16 @@ def add_fields(env, field_spec):
         sql_type = vals[4]
         module = vals[5]
         init_value = vals[6] if len(vals) > 6 else False
-        # Add SQL column
         if not table_name:
             try:
                 table_name = env[model_name]._table
             except KeyError:
                 table_name = get_model2table(model_name)
-        if not column_exists(env.cr, table_name, field_name):
-            sql_type = sql_type or sql_type_mapping.get(field_type)
-            if sql_type:
-                query = sql.SQL("ALTER TABLE {} ADD COLUMN {} {}").format(
-                    sql.Identifier(table_name),
-                    sql.Identifier(field_name),
-                    sql.SQL(sql_type),
-                )
-                args = []
-                if init_value:
-                    query += sql.SQL(" DEFAULT %s")
-                    args.append(init_value)
-                logged_query(env.cr, query, args)
-                if init_value:
-                    logged_query(
-                        env.cr,
-                        sql.SQL("ALTER TABLE {} ALTER COLUMN {} DROP DEFAULT").format(
-                            sql.Identifier(table_name),
-                            sql.Identifier(field_name),
-                        ),
-                    )
+        # Add SQL column
+        add_columns(
+            env,
+            [(model_name, field_name, field_type, init_value, table_name, sql_type)],
+        )
         # Add ir.model.fields entry
         env.cr.execute(
             "SELECT id FROM ir_model WHERE model = %s",