From f243b71dcb9c6910c373c6506c7ff23a2663f0ad Mon Sep 17 00:00:00 2001 From: Raphael Collet Date: Fri, 9 Oct 2020 09:36:53 +0000 Subject: [PATCH] [FIX] core: optimize first snaphot in onchange This patch speeds up the performance of method `onchange`. Our use-case is an invoice with 300 lines, where we modify the unit price or quantity on several lines. Each modification triggers a call to `onchange` on the invoice itself. The latter call went from 1.3 to 0.8 seconds, which represents a speedup of 30% to 40%. In the implementation of `onchange`, the first snapshot is preceded by a "prefetching" phase, where the lines of x2many fields are read, so that the fields of unmodified lines are in cache. This is useful because the fields of those lines are not sent by the client, which only sends ids. This prefetching represents more than 40% of the duration of `onchange`, in our use-case. The prefetching is inefficient for several reasons. First, it uses `mapped`, which formats data that is actually never used. Second, it accesses new records that have the actual lines as origin. And on those records, computed stored fields are not taken from the origin record, but are (uselessly) computed instead. We have optimized the prefetching in the following way. It now reads stored fields on the actual lines (using `_read` to avoid formatting), then copies the cache of those fields on the corresponding new lines (to avoid useless computations). This makes the prefetching about 10 times faster! closes odoo/odoo#59781 X-original-commit: ec50c426d7c2a17c7b72e64adab65eda6328e163 Signed-off-by: Raphael Collet (rco) --- odoo/models.py | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/odoo/models.py b/odoo/models.py index 6dbb0d7acbf..ab732747901 100644 --- a/odoo/models.py +++ b/odoo/models.py @@ -6065,20 +6065,34 @@ Fields: if name not in values ])) - # prefetch x2many lines without data (for the initial snapshot) + # prefetch x2many lines: this speeds up the initial snapshot by avoiding + # to compute fields on new records as much as possible, as that can be + # costly and is not necessary at all for name, subnames in nametree.items(): if subnames and values.get(name): - # retrieve all ids in commands + # retrieve all line ids in commands line_ids = set() for cmd in values[name]: if cmd[0] in (1, 4): line_ids.add(cmd[1]) elif cmd[0] == 6: line_ids.update(cmd[2]) - # build corresponding new lines, and prefetch fields - new_lines = self[name].browse(NewId(id_) for id_ in line_ids) - for subname in subnames: - new_lines.mapped(subname) + # prefetch stored fields on lines + lines = self[name].browse(line_ids) + fnames = [subname + for subname in subnames + if lines._fields[subname].base_field.store] + lines._read(fnames) + # copy the cache of lines to their corresponding new records; + # this avoids computing computed stored fields on new_lines + new_lines = lines.browse(map(NewId, line_ids)) + cache = self.env.cache + for fname in fnames: + field = lines._fields[fname] + cache.update(new_lines, field, [ + field.convert_to_cache(value, new_line, validate=False) + for value, new_line in zip(cache.get_values(lines, field), new_lines) + ]) # Isolate changed values, to handle inconsistent data sent from the # client side: when a form view contains two one2many fields that