[FIX] util/pg: get common column name with type or typcategory

get the coomin columns info with same typcategory or
same data type and skipp the column with different
datatype and different type

```
Traceback (most recent call last):
  File "/home/odoo/src/odoo/19.0/odoo/service/server.py", line 1514, in preload_registries
    registry = Registry.new(dbname, update_module=update_module, install_modules=config['init'], upgrade_modules=config['update'], reinit_modules=config['reinit'])
  File "/home/odoo/src/odoo/19.0/odoo/tools/func.py", line 88, in locked
    return func(inst, *args, **kwargs)
  File "/home/odoo/src/odoo/19.0/odoo/orm/registry.py", line 186, in new
    load_modules(
  File "/home/odoo/src/odoo/19.0/odoo/modules/loading.py", line 493, in load_modules
    migrations.migrate_module(package, 'end')
  File "/home/odoo/src/odoo/19.0/odoo/modules/migration.py", line 220, in migrate_module
    exec_script(self.cr, installed_version, pyfile, pkg.name, stage, stageformat[stage] % version)
  File "/home/odoo/src/odoo/19.0/odoo/modules/migration.py", line 257, in exec_script
    mod.migrate(cr, installed_version)
  File "/tmp/tmp7yriz79e/migrations/hr/saas~18.4.1.1/end-migrate.py", line 87, in migrate
    cr.execute(query, [e[1] for e in required_default_values])
  File "/home/odoo/src/odoo/19.0/odoo/sql_db.py", line 426, in execute
    self._obj.execute(query, params)
psycopg2.errors.DatatypeMismatch: column "fondo_ahorro" is of type boolean but expression is of type double precision
LINE 16: ..."."distance_home_work_unit", "e"."employee_type", "e"."fondo...
                                                              ^
HINT:  You will need to rewrite or cast the expression.
```

```
select id,name,model,ttype,store from ir_model_fields where name='fondo_ahorro';
  id   |     name     |         model         |  ttype  | store
-------+--------------+-----------------------+---------+-------
 28361 | fondo_ahorro | hr.employee           | float   | t
 28687 | fondo_ahorro | calculo.liquidaciones | float   | t
 28379 | fondo_ahorro | hr.version            | boolean | t
(3 rows)
```

upg-3444635
opw-5260147

Author: sagu-odoo

src/util/pg.py

@@ -1227,30 +1227,52 @@ def get_common_columns(cr, table1, table2, ignore=("id",)):
     :param str table1: first table name whose columns are retrieved
     :param str table2: second table name whose columns are retrieved
     :param list(str) ignore: list of column names to ignore in the returning list
-    :return: a list of column names present in both tables
+    :return: a list of column names present in both tables with same data type
     :rtype: :class:`~odoo.upgrade.util.pg.ColumnList`
     """
     _validate_table(table1)
     _validate_table(table2)
 
     cr.execute(
         """
-            WITH _common AS (
-                SELECT column_name
-                  FROM information_schema.columns
-                 WHERE table_schema = 'public'
-                   AND table_name IN %s
-                   AND column_name != ALL(%s)
-              GROUP BY column_name
-                HAVING count(table_name) = 2
+            WITH _cols AS (
+                SELECT c.table_name, c.column_name, t.typcategory, c.udt_name AS data_type
+                  FROM information_schema.columns c
+                  JOIN pg_type t ON c.udt_name = t.typname
+                 WHERE c.table_schema = 'public'
+                   AND c.table_name IN %s
+            ),
+            _common AS (
+                SELECT c1.column_name, c1.data_type AS type_t1, c2.data_type AS type_t2, c1.typcategory AS cat_t1,
+                       c2.typcategory AS cat_t2, (c1.typcategory = c2.typcategory) AS is_compatible,
+                       (c1.typcategory = c2.typcategory AND c1.data_type != c2.data_type) AS is_managable
+                  FROM _cols c1
+                  JOIN _cols c2 
+                    ON c1.column_name = c2.column_name
+                   AND c1.table_name = %s
+                   AND c2.table_name = %s
             )
-            SELECT coalesce(array_agg(column_name::varchar ORDER BY column_name), ARRAY[]::varchar[]),
-                   coalesce(array_agg(quote_ident(column_name) ORDER BY column_name), ARRAY[]::varchar[])
-              FROM _common
+             SELECT coalesce(array_agg(column_name ORDER BY column_name) FILTER (WHERE is_compatible or is_managable), ARRAY[]::varchar[]) AS column_names,
+                    coalesce(array_agg(quote_ident(column_name) ORDER BY column_name) FILTER (WHERE is_compatible or is_managable), ARRAY[]::varchar[]) AS quoted_column_names,
+                    coalesce(array_agg(column_name) FILTER (WHERE is_managable), ARRAY[]::varchar[]) AS same_typcatg_columns,
+                    coalesce(array_agg(column_name) FILTER (WHERE not is_compatible), ARRAY[]::varchar[]) AS diff_typcatg_columns
+               FROM _common
         """,
-        [(table1, table2), list(ignore)],
+        [(table1, table2), table1, table2, list(ignore)],
     )
-    return ColumnList(*cr.fetchone())
+    common_columns, quoted_common_columns, same_typcatg_columns, diff_typcatg_columns = cr.fetchone()
+    if same_typcatg_columns:
+        logger.warning(
+            "Columns with same type category but different types between %s and %s: %s",
+            table1, table2, ", ".join(same_typcatg_columns)
+        )
+    if diff_typcatg_columns:
+        logger.warning(
+            "Columns with incompatible type categories between %s and %s: %s",
+            table1, table2, ", ".join(diff_typcatg_columns)
+        )
+
+    return ColumnList(common_columns, quoted_common_columns)
 
 
 def rename_table(cr, old_table, new_table, remove_constraints=True):