Gecachte Computed Fields in Odoo: De Complete Handleiding

Introductie

Als je met Odoo werkt, kom je vaak velden tegen waarvan de waarde automatisch bepaald wordt. Een opgeslagen berekend veld gaat verder: de berekende waarde wordt niet alleen getoond, maar ook daadwerkelijk weggeschreven naar de database, zodat ze net zo beschikbaar is als een gewone kolom.

Dat verschil heeft aanzienlijke gevolgen. Een veld dat alleen bij het tonen berekend wordt, kun je moeilijk of niet efficiënt doorzoeken, filteren of groeperen. Een opgeslagen berekend veld daarentegen kan je gebruiken in zoekfilters, exporten en SQL-queries, omdat de waarde in de tabel staat.

In deze handleiding vind je alles wat je moet weten over opgeslagen berekende velden in Odoo: hoe ze in het datamodel functioneren, hoe je ze maakt met Odoo Studio of in Python, concrete bedrijfsvoorbeelden en de fouten die je best vermijdt.

Wat is een opgeslagen berekend veld in Odoo

Binnen de Odoo ORM bevat elk model velden met data die meestal de gebruiker invoert. Een berekend veld onderscheidt zich doordat de waarde niet handmatig is ingevuld maar voortkomt uit logica in Python.

Een opgeslagen berekend veld is in essentie een berekend veld met store=True. Wanneer afhankelijke velden wijzigen, voert Odoo de berekeningsfunctie uit en schrijft de uitkomst naar de databasekolom — vanaf dat moment werkt het veld als elk ander opgeslagen veld.

In Python volgt dit een eenvoudige patroon:

total_amount = fields.Float(
    string='Totaalbedrag',
    compute='_compute_total_amount',
    store=True,
)

@api.depends('quantity', 'unit_price')
def _compute_total_amount(self):
    for record in self:
        record.total_amount = record.quantity * record.unit_price

Het argument store=True is het onderscheidende kenmerk: zonder dat attribuut wordt de waarde telkens dynamisch berekend bij uitlezen en niet in de database opgeslagen.

In de gebruikersinterface zie je een opgeslagen berekend veld niet van een normaal veld verschillen. Het verschijnt op formulier- en lijstweergaven, is opneembaar in exports en kan gebruikt worden in filters en groeperingen, zonder visuele aanduiding dat de waarde berekend is.

Opgeslagen versus niet-opgeslagen berekende velden

Het onderscheid is cruciaal voor elke Odoo-aanpassing of ontwikkeling:

• Niet-opgeslagen berekend veld: Berekend bij het uitlezen. Niet bruikbaar in zoekfilters of group-by. Minder opslagruimte maar niet beschikbaar voor database-gebaseerde queries.
• Opgeslagen berekend veld: Berekend bij wijziging van afhankelijkheden en weggeschreven naar de database. Doorzoekbaar, filterbaar en exporteerbaar. Neemt schijfruimte in zoals een gewone kolom.

De keuze hangt af van het gebruiksdoel. Voor een veld dat enkel op één formulier getoond wordt, volstaat een niet-opgeslagen veld. Heb je nood aan sorteren, filteren of aggregeren, kies dan voor opgeslagen.

Hoe het veld werkt

Bij het definiëren van een opgeslagen berekend veld zorgt de Odoo ORM automatisch voor triggers op basis van de velden die je in @api.depends() opneemt.

Wanneer één van die afhankelijkheden verandert, merkt Odoo het op, markeert het record voor herberekening, voert de compute-functie uit en schrijft de nieuwe waarde terug naar de databasekolom.

Levenscyclus van herberekening

Stappen die doorgaans doorlopen worden:

1. Iemand of een proces wijzigt een veld dat in @api.depends() staat.
2. Odoo detecteert de wijziging en bepaalt welke records hierdoor geraakt worden.
3. De compute-methode wordt voor die records uitgevoerd.
4. De berekende waarde wordt naar de database geschreven.
5. De veldwaarde is nu beschikbaar voor zoeken, filteren en exporteren met de bijgewerkte waarde.

Meestal gebeurt dit synchron binnen dezelfde transactie. Bij grote batches kan Odoo recomputaties uitstellen en them op de achtergrond afhandelen.

Afhankelijkheden over gerelateerde modellen heen

In @api.depends() kun je paden met punten gebruiken om velden op gerelateerde modellen te volgen. Bijvoorbeeld:

@api.depends('partner_id.country_id.name')
def _compute_country_name(self):
    for record in self:
        record.country_name = record.partner_id.country_id.name or ''

Odoo volgt in dat voorbeeld wijzigingen op partner_id, country_id en name over meerdere modellen. Als de landnaam bij een partner verandert, worden gekoppelde records automatisch herberekend — dat is een krachtig onderdeel van het Odoo-framework.

Effect op de database

Omdat het veld opgeslagen wordt, maakt Odoo een echte kolom in de PostgreSQL-tabel aan. Daardoor nemen zulke velden actief deel aan SQL-queries en zijn zoekacties en filters even snel als bij gewone velden.

Zakelijke toepassingen

Opgeslagen berekende velden komen in de praktijk in heel wat scenario's terug. Vijf concrete voorbeelden uit bedrijfsprocessen:

1. Verkoop: winstmarge op orderregels

Verkoopteams willen snel de marge per orderregel zien. Een opgeslagen berekend veld neemt verkoopprijs en kostprijs, berekent de marge en bewaart die waarde op de regel. Zo kan de manager onmiddellijk filteren op marges, verlieslatende regels vinden en pivotrapporten maken op marges.

2. CRM: dagen zonder activiteit op een lead

Op een lead kun je een opgeslagen veld bewaren dat bijhoudt hoeveel dagen sinds de laatste actie verstreken zijn. In combinatie met een geplande taak die elke ochtend recompute aanroept, kun je leads filteren op inactiviteit en automatisch opvolging prioriteren.

3. Voorraad: netto beschikbare hoeveelheid

Voor producten met complexe stockregels kun je vooraf berekende beschikbaarheid bewaren (bv. voorraad minus gereserveerd). Omdat die waarde opgeslagen is, kunnen productmanagers gemakkelijk sorteren en filteren zonder dat Odoo continu zware stockberekeningen moet uitvoeren voor elke rij.

4. Boekhouding: aantal openstaande achterstallige facturen per klant

Op het contact kun je een opgeslagen veld hebben dat telt hoeveel facturen achterstallig zijn. Boekhouders kunnen zo in één oogopslag klanten sorteren op achterstallige betalingen — iets dat alleen snel werkt wanneer de telling in de database staat.

5. Productie: totale geschatte bewerkingstijd

In een stuklijst kun je een opgeslagen veld gebruiken om de totale geschatte bewerkingstijd over alle bewerkingen op te tellen. Planners kunnen stuklijsten filteren en sorteren op totale arbeidstijd, wat handig is voor capaciteitsplanning; elke wijziging in bewerkingen triggert automatisch een update.

Een veld aanmaken of aanpassen

Je kunt opgeslagen berekende velden aanmaken via Odoo Studio voor eenvoudige gevallen of via Python in een custom module als je volledige controle nodig hebt.

Werken met Odoo Studio

Odoo Studio laat je zonder code berekende velden toevoegen. Bij het aanmaken van een Integer-, Float- of Monetary-veld kun je een formuleoptie inschakelen en een expressie opgeven. Studio regelt de dependency-tracking automatisch.

Studio is ideaal voor eenvoudige rekenkundige expressies op hetzelfde record: snel op te zetten zonder ontwikkelomgeving. Zodra de logica echter gerelateerde modellen, conditionele stappen of aggregaties over kindrecords vereist, schiet Studio tekort en heb je een custom module nodig.

Belangrijk voor je Odoo-aanpassing: Studio is snel voor eenvoudige gevallen; voor complexere logica kies je altijd voor Python zodat je alle mogelijkheden hebt.

Werken met een custom Python-module

Voor geavanceerdere berekeningen definieer je het veld in Python binnen een module. Een concreet voorbeeld: een veld voor margepercentage op sale.order.line.

from odoo import models, fields, api

class SaleOrderLine(models.Model):
    _inherit = 'sale.order.line'

    x_margin_pct = fields.Float(
        string='Winst %',
        compute='_compute_margin_pct',
        store=True,
        digits=(5, 2),
    )

    @api.depends('price_unit', 'purchase_price')
    def _compute_margin_pct(self):
        for line in self:
            if line.price_unit:
                line.x_margin_pct = (
                    (line.price_unit - line.purchase_price) / line.price_unit
                ) * 100
            else:
                line.x_margin_pct = 0.0

Na installatie voegt Odoo de kolom x_margin_pct toe, voert de berekening uit voor bestaande records en begint vanaf dan wijzigingen in price_unit en purchase_price te volgen.

De x_-prefix is de gebruikelijke conventie voor custom velden om conflicten met kernvelden te vermijden — een standaardpraktijk in Odoo-ontwikkeling.

Een opgeslagen berekend veld bewerkbaar maken

Standaard zijn berekende velden read-only. Wil je gebruikers toelaten de berekende waarde handmatig te overschrijven, implementeer dan een inverse-methode naast de compute-methode. Die inverse past bij een write de bronvelden aan zodat de handmatige wijziging consistent blijft — handig wanneer de berekende waarde meestal correct is maar soms een uitzondering behoeft.

Odoo Studio-velden en de XML-RPC API

Via de XML-RPC API kun je standaardvelden aanmaken via het model ir.model.fields. Voor opgeslagen berekende velden met complexe Python-logica moet de compute-functie echter op de server staan in een module. De API is bruikbaar voor het provisionen van simpele velden, maar complexe berekeningen blijven server-side code vereisen.

Aanbevolen werkwijzen

Hieronder staan best practices die ervaren Odoo-consultants volgen bij opgeslagen berekende velden.

Declareer alle afhankelijkheden nauwkeurig

Zet in @api.depends() elk veld dat je compute-methode leest. Vergeet je er één, dan worden updates niet getriggerd. Loop je berekening systematisch na en voeg elke veldtoegang toe aan de decorator.

Houd compute-methodes snel

De compute-methode draait voor elke getroffen record; in drukke systemen kunnen dat er duizenden zijn. Vermijd extra databasequeries binnen compute-methodes. Gebruik bij voorkeur reeds geladen velden in plaats van aanvullende searches.

Gebruik store=True alleen wanneer nodig

Opgeslagen velden kosten schijfruimte en veroorzaken schrijfbewerkingen bij elke recomputatie. Als je het veld enkel toont en nooit zoekt of groepeert, volstaat een niet-opgeslagen veld en bespaar je resources.

Behandel randgevallen in de compute-methode

Voorzie checks voor lege waarden, deling door nul of ontbrekende gerelateerde records. Zulke situaties veroorzaken vaak stilletjes fouten. Stel veilige defaultwaarden in als de normale berekening niet mogelijk is.

Plan de initiële recomputatie op grote tabellen

Bij installeren van een module met nieuw opgeslagen veld recomputeert Odoo alle bestaande rijen. Op grote tabellen kan dat veel tijd kosten. Test migraties in staging en plan mogelijke downtime of achtergrondverwerking voor productie-implementaties.

Vermijd circulaire afhankelijkheden

Als veld A van veld B afhangt en veld B van veld A, krijg je een fout bij het laden van het module. Ontwerp afhankelijkheden zo dat ze eenrichtingsstromen vormen.

Veelvoorkomende valkuilen

Veelgemaakte fout: vergeten van store=True

Dit is de meest voorkomende vergissing. Het veld lijkt correct op formulieren, maar wanneer iemand er een filter mee wil maken of het in een rapport wil gebruiken, werkt het niet. Bepaal van tevoren of het veld doorzoekbaar moet zijn en voeg store=True toe als dat het geval is.

Een dependency vergeten in @api.depends

Als je compute-methode partner_id.country_id leest maar je decorator alleen partner_id vermeldt, wordt het veld niet bijgewerkt wanneer het land verandert. Volg iedere toegangspad en vermeld elk onderdeel expliciet.

Stille fouten in de compute-methode

Als de compute-methode voor een record een uitzondering veroorzaakt, slaat Odoo die recomputatie stilletjes over en blijft de oude opgeslagen waarde staan. De fout verschijnt mogelijk in de serverlogs maar niet aan de gebruiker, wat leidt tot verouderde of onjuiste waarden. Test je methode op records met ontbrekende of afwijkende data.

Prestatieproblemen bij grote datasets

Een methode die goed werkt in ontwikkeling kan in productie een bottleneck worden zodra tabellen sterk groeien. Let op het aantal DB-queries per record: één extra query per record maal tienduizenden records betekent tienduizenden extra queries bij een save.

Gebruik van sudo() in compute-methodes

Het aanroepen van sudo() om toegangsrechten te omzeilen is risicovol. Als de berekende waarde data onthult die de huidige gebruiker niet zou mogen zien, ondermijn je het permissiemodel. Gebruik sudo() alleen na zorgvuldige afweging van de veiligheidseffecten.

Rekening houden met deferred recomputatie

Recomputatie is vaak synchroon in interactieve flows, maar bij batchimports, achtergrondjobs of bepaalde contextflags kan Odoo recomputaties uitstellen. Bouw geen bedrijfslogica die ervan uitgaat dat de opgeslagen waarde onmiddellijk en altijd up-to-date is; controleer het gedrag in de concrete context.

Samengevat

Opgeslagen berekende velden zijn een van de krachtigste middelen bij het uitbreiden van Odoo: ze automatiseren berekeningen, houden data consistent en maken records doorzoekbaar en exporteerbaar zonder manueel werk van gebruikers.

Belangrijkste aandachtspunten om te onthouden:

• Gebruik store=True wanneer je wil dat het veld doorzoekbaar, filterbaar of exporteerbaar is.
• Vermeld altijd alle afhankelijkheden in @api.depends(), inclusief paden over meerdere modellen.
• Maak compute-methodes snel en behandel randgevallen expliciet.
• Voor simpele formules is Odoo Studio handig; voor complexere logica schrijf je Python.
• Houd rekening met initiële recomputatie bij uitrol op grote tabellen.

Of je nu een nieuwe module bouwt, een bestaand model uitbreidt of Odoo-veldtypen leert kennen: opgeslagen berekende velden verbinden de ORM, de database en je bedrijfslogica en verdienen een grondige aanpak.

Hulp nodig met je Odoo-implementatie?

Dasolo ondersteunt bedrijven bij het implementeren, aanpassen en optimaliseren van Odoo voor uiteenlopende bedrijfsbehoeften. Of je nu berekende velden wil toevoegen, rapporten op basis van berekende waarden wil bouwen of je Odoo-ontwikkeling wil opschalen, ons team heeft de ervaring om te helpen.

Neem contact met ons op voor ondersteuning bij je Odoo-project. We bekijken graag je case en zoeken samen de beste aanpak voor jouw organisatie.