[FIX] orm: in recompute_fields, avoid memory error from postgresql

improves 13adede

Queries run through client-side cursors will make postgresql materialze the
whole of the result immediately (which is actually, why `cr.rowcount` is always
available right after `execute` in this case). With server side cursors (named
cursors) on the other hand, tuples are materialized when they are fetched.

This is why running the `query` for ids through the client-side cursor just to
be able to access `cr.rowcount`, can cause an out-of-memory exception from
PostgreSQL. We fix this by wrapping the query as a subquery into a `SLEECT
count(*)`, which allows PostgreSQL to materialze just a single tuple.

Also, there is no need to fetch a million ids at once, so to go ligth on memory
on the python side as well, we reduce teh `itersize` to 100k.

Author: cawo-odoo

src/util/orm.py

@@ -289,14 +289,16 @@ def recompute_fields(cr, model, fields, ids=None, logger=_logger, chunk_size=256
 
     if ids is None:
         query = format_query(cr, "SELECT id FROM {} ORDER BY id", table_of_model(cr, model)) if query is None else query
-        cr.execute(query)
-        count = cr.rowcount
-        if count < 2**21:  # avoid the overhead of a named cursor unless we have at least two chunks
+        count_query = "SELECT count(*) FROM ({query}) AS count".format(query=query)
+        cr.execute(count_query)
+        count = cr.fetchone()[0]
+        itersize = BIG_TABLE_THRESHOLD
+        if count < 2 * itersize:  # avoid the overhead of a named cursor unless we have at least two chunks
             ids_ = (id_ for (id_,) in cr.fetchall())
         else:
 
             def get_ids():
-                with named_cursor(cr, itersize=2**20) as ncr:
+                with named_cursor(cr, itersize=itersize) as ncr:
                     ncr.execute(query)
                     for (id_,) in ncr:
                         yield id_