Opgeslagen Berekende Velden in Odoo: De Ultieme Gids

Inleiding

Als je tijd hebt besteed aan het werken met Odoo, heb je waarschijnlijk velden tegengekomen die hun waarde automatisch berekenen. Een opgeslagen berekend veld gaat een stap verder: het berekent de waarde en slaat deze direct op in de database.

Dit onderscheid is belangrijker dan het op het eerste gezicht lijkt. Een veld dat alleen on-the-fly berekent, kan niet efficiënt worden doorzocht, gefilterd, gegroepeerd of geëxporteerd. Een opgeslagen berekend veld kan dat wel. Het gedraagt zich als een reguliere databasekolom terwijl het nog steeds wordt aangedreven door logica die je definieert.

Deze gids behandelt alles wat je moet weten over opgeslagen berekende velden in Odoo: hoe ze werken binnen het Odoo datamodel, hoe je ze kunt maken met Odoo Studio of Python, echte zakelijke gebruikscases en de meest voorkomende fouten die je moet vermijden.

Wat is een opgeslagen berekend veld in Odoo

In de Odoo ORM houdt elk veld op een model een stuk gegevens vast. De meeste velden slaan op wat de gebruiker handmatig invoert. Een berekend veld is anders: de waarde wordt gegenereerd door een Python-functie in plaats van door een gebruiker ingevoerd.

Een opgeslagen berekend veld is simpelweg een berekend veld met store=True. Wanneer de afhankelijkheden veranderen, voert Odoo de berekeningsfunctie uit en schrijft het resultaat in de databasekolom. De waarde is dan beschikbaar zoals elk ander veld.

In Python ziet het basispatroon er als volgt uit:

totaal_bedrag = fields.Float(
    string='Totaal Bedrag',
    compute='_compute_totaal_bedrag',
    store=True,
)

@api.depends('hoeveelheid', 'eenheidsprijs')
def _compute_totaal_bedrag(self):
    for record in self:
        record.totaal_bedrag = record.hoeveelheid * record.eenheidsprijs

De store=True parameter is wat een opgeslagen berekend veld scheidt van een regulier berekend veld. Zonder deze parameter wordt de waarde elke keer opnieuw berekend wanneer het veld wordt gelezen, maar nooit in de database opgeslagen.

In de Odoo-interface ziet een opgeslagen berekend veld er precies uit als elk ander veld. Gebruikers zien het op formulieren, lijstweergaven en rapporten. Ze kunnen er op filteren, records groeperen met behulp ervan en het opnemen in exports. Er is geen visuele indicator dat de waarde is berekend in plaats van ingevoerd.

Opgeslagen vs Niet-opgeslagen Berekende Velden

Het begrijpen van dit verschil is essentieel voor elk Odoo-ontwikkelings werk:

• Niet-opgeslagen berekende veld: Wordt on-the-fly berekend wanneer gelezen. Kan niet worden gebruikt in filters, zoekopdrachten of group-by. Lichter in opslag, maar niet beschikbaar voor databasequery's.
• Opgeslagen berekende veld: Wordt berekend wanneer afhankelijkheden veranderen en opgeslagen in de database. Doorzoekbaar, filterbaar, exporteerbaar. Neemt ruimte in de database in zoals elke reguliere kolom.

De keuze tussen de twee gaat niet over welke beter is in het algemeen. Het hangt af van waarvoor je het veld nodig hebt. Als je het alleen op een enkel formulier weergeeft, is niet-opgeslagen prima. Als je moet filteren, sorteren of aggregeren op basis daarvan, gebruik dan opgeslagen.

Hoe het veld werkt

Wanneer je een opgeslagen berekend veld in Odoo definieert, stelt de ORM automatische herberekenings-trigger in op basis van de velden die zijn vermeld in de @api.depends() decorator.

Wanneer een van die afhankelijke velden op een record verandert, markeert Odoo dat record als zijnde dat het herberekening nodig heeft. De compute-methode wordt uitgevoerd en het resultaat wordt teruggeschreven naar de databasekolom voor dat veld.

De Recomputation Lifecycle

Hier is wat er stap voor stap gebeurt:

1. Een gebruiker of geautomatiseerd proces wijzigt een veld dat is vermeld in @api.depends().
2. Odoo detecteert de wijziging en identificeert alle records die afhankelijk zijn van dit veld.
3. De compute-methode wordt aangeroepen voor die records.
4. De berekende waarde wordt naar de databasekolom geschreven.
5. Het veld is nu beschikbaar voor zoeken, filteren en exporteren met de bijgewerkte waarde.

In de meeste gevallen gebeurt deze herberekening onmiddellijk binnen dezelfde transactie. Voor grote batchbewerkingen kan Odoo sommige herberekeningen uitstellen en deze op de achtergrond verwerken.

Afhankelijkheden Over Gerelateerde Modellen

De @api.depends() decorator ondersteunt gedoteerde paden voor het benaderen van velden op gerelateerde modellen. 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 ''

In dit geval houdt Odoo wijzigingen bij op partner_id, country_id en name over modellen heen. Als de landnaam verandert bij een partner, worden alle gerelateerde records automatisch herberekend. Dit is een van de krachtigste aspecten van het Odoo-framework.

Database Impact

Omdat het veld is opgeslagen, creëert Odoo een echte kolom in de PostgreSQL-databasetabel. Dit betekent dat het veld direct deelneemt aan SQL-query's. Zoekopdrachten en filters op opgeslagen berekende velden zijn snel en efficiënt, net als zoekopdrachten op reguliere velden.

Zakelijke gebruikscases

Opgeslagen berekende velden verschijnen in alle gebieden van Odoo. Hier zijn vijf praktische voorbeelden uit echte bedrijfsworkflows.

1. Verkoop: Margepercentage op Orderregels

Een verkoopteam wil het margepercentage op elke verkooporderregel zien zonder een rekenmachine te openen. Een opgeslagen berekend veld neemt de eenheidsprijs en de kostprijs, berekent de marge en slaat deze op de regel op. De verkoopmanager kan vervolgens bestellingen filteren op margepercentage, onrendabele regels onmiddellijk vinden en groeperen op margebanden in draaitabellen.

2. CRM: Dagen Zonder Activiteit op een Lead

Een opgeslagen berekend veld op het CRM-leadmodel kan bijhouden hoeveel dagen zijn verstreken sinds de laatste geplande activiteit. Combineer dit met een geplande actie die elke ochtend de herberekening activeert, en uw verkoopteam kan leads filteren op inactiviteitsdrempel. Geen handmatige opvolging vereist.

3. Voorraad: Netto Beschikbare Hoeveelheid

Voor producten met complexe voorraadregels kan een opgeslagen berekend veld een vooraf berekende waarde bevatten, zoals de beschikbare hoeveelheid minus de gereserveerde hoeveelheid. Omdat de waarde is opgeslagen, kunnen productmanagers de productlijst sorteren en filteren op beschikbaarheid zonder dat Odoo complexe voorraadberekeningen live voor elke rij op het scherm uitvoert.

4. Boekhouding: Aantal Achterstallige Facturen per Klant

Op het klantmodel kan een opgeslagen berekend veld tellen hoeveel facturen momenteel achterstallig zijn. Wanneer het boekhoudingsteam de contactenlijst opent, kunnen ze klanten met één klik sorteren op het aantal achterstallige facturen. Dit is alleen mogelijk omdat de telling in de database is opgeslagen in plaats van on-the-fly voor elke rij te worden berekend.

5. Productie: Totale Geschatte Werkduur

In een Bill of Materials kan een opgeslagen berekend veld de geschatte duur optellen over alle werkcentrumoperaties die aan de BOM zijn gekoppeld. Productieplanners kunnen vervolgens BOM's filteren en sorteren op totale werktijd, wat nuttig is voor capaciteitsplanning en scheduling. Elke keer dat een operatie wordt toegevoegd of gewijzigd, worden de totalen automatisch bijgewerkt.

Het veld maken of aanpassen

Er zijn twee hoofdmethoden om opgeslagen berekende velden in Odoo te maken: met Odoo Studio voor eenvoudige gevallen, of door Python-code te schrijven in een aangepaste module voor volledige controle.

Odoo Studio gebruiken

Odoo Studio stelt je in staat om berekende velden toe te voegen zonder enige code te schrijven. Wanneer je een nieuw veld van het type Integer, Float of Monetary in Studio maakt, kun je een formule-optie inschakelen die een Python-achtige expressie accepteert. Studio beheert de afhankelijkheidsregistratie op de achtergrond.

Studio-berekende velden zijn een goede keuze wanneer de logica een eenvoudige rekenkundige expressie tussen velden op hetzelfde record is. Ze zijn eenvoudig in te stellen en vereisen geen ontwikkelomgeving. Echter, ze hebben echte beperkingen. Als je logica gerelateerde modelvelden, voorwaardelijke takken of aggregatie over kindrecords omvat, zal Studio niet voldoende zijn. Je hebt een aangepaste module nodig.

Dit is een belangrijke onderscheid wanneer je jouw Odoo-aanpassing plant: Studio is snel voor rechttoe rechtaan gevallen, maar Python biedt je volledige flexibiliteit wanneer de logica complex wordt.

Een aangepaste Python-module gebruiken

Voor alles wat verder gaat dan basisformules, definieer je het veld in Python binnen een aangepaste Odoo-module. Hier is een concreet voorbeeld dat een margepercentageveld toevoegt aan verkooporderregels:

from odoo import models, fields, api

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

    x_margin_pct = fields.Float(
        string='Marge %',
        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

Wanneer deze module is geïnstalleerd, creëert Odoo de x_margin_pct kolom in de database, voert de compute-methode uit voor alle bestaande records en begint wijzigingen in price_unit en purchase_price vanaf dat moment bij te houden.

Het veldprefix x_ is de conventie voor aangepaste velden in Odoo om conflicten met kernvelden te vermijden. Dit is standaardpraktijk in Odoo-ontwikkeling.

Een opgeslagen berekend veld bewerkbaar maken

Standaard zijn berekende velden alleen-lezen. Als je wilt dat gebruikers de berekende waarde handmatig kunnen overschrijven, kun je een inverse methode definiëren naast je compute-methode. De inverse-methode wordt uitgevoerd wanneer een gebruiker rechtstreeks naar het veld schrijft en kan de bronvelden dienovereenkomstig bijwerken. Dit patroon is nuttig voor velden waarbij de berekende waarde een goede standaard is, maar soms een handmatige overschrijving nodig heeft.

Odoo Studio Velden en de XML-RPC API

Voor teams die Odoo-databasevelden beheren via de XML-RPC API, kun je standaardvelden aanmaken via het ir.model.fields model. Voor opgeslagen berekende velden met aangepaste Python-logica moet de compute-methode zelf echter in server-side code staan. De API-aanpak werkt goed voor het provisioneren van eenvoudige velden als onderdeel van geautomatiseerde implementaties, maar de logica achter een berekend veld vereist altijd een aangepast module die op de server is geïnstalleerd.

Beste praktijken

Hier zijn de praktijken die ervaren Odoo-consultants volgen bij het werken met opgeslagen berekende velden.

Declareer Alle Afhankelijkheden Nauwkeurig

De @api.depends() decorator moet elk veld opsommen dat je compute-methode leest. Als je er een vergeet, wordt het veld niet bijgewerkt wanneer die afhankelijkheid verandert. Ga je compute-methode regel voor regel door en zorg ervoor dat elke veldtoegang in de decorator is vermeld.

Houd Compute-methoden Snel

Je compute-methode draait op elk record dat wordt beïnvloed door een afhankelijkheidsverandering. In een drukke Odoo-instantie kan dit betekenen dat duizenden records tegelijk worden verwerkt. Vermijd databasequery's binnen compute-methoden wanneer mogelijk. Als je toegang nodig hebt tot gerelateerde gegevens, gebruik dan de velden die al zijn geladen in plaats van extra zoekopdrachten uit te voeren.

Gebruik alleen store=True Wanneer Je Het Nodig Hebt

Opgeslagen velden verbruiken databasecapaciteit en triggeren schrijfoperaties bij elke herberekening. Als je het veld alleen op een formulierweergave hoeft weer te geven en er nooit op wilt filteren of groeperen, is een niet-opgeslagen berekend veld de lichtere optie. Maak deze beslissing opzettelijk in plaats van standaard voor alles opgeslagen te kiezen.

Behandel Randgevallen in de Compute-methode

Reken altijd rekening met lege of ontbrekende waarden in je compute-methode. Delen door nul, ontbrekende gerelateerde records en null-waarden zijn veelvoorkomende oorzaken van stille fouten in berekende velden. Voeg expliciete controles toe en stel veilige standaardwaarden in wanneer de normale berekening niet kan doorgaan.

Plan voor initiële herberekening op grote tabellen

Wanneer je een module installeert die een nieuw opgeslagen berekend veld toevoegt, herberekent Odoo dit voor elk bestaand record in de tabel. Op een tabel met honderden duizenden rijen kan dit een aanzienlijke hoeveelheid tijd kosten. Test je migratie eerst in een staging-omgeving en plan voor mogelijke downtime of achtergrondverwerking bij het uitrollen naar productie.

Vermijd circulaire afhankelijkheden

Als veld A afhankelijk is van veld B en veld B afhankelijk is van veld A, zal Odoo een foutmelding geven wanneer de module wordt geladen. Ontwerp je afhankelijkheden van berekende velden zodat ze slechts in één richting stromen.

Veelvoorkomende valkuilen

Vergeten store=True

Dit is de meest voorkomende fout. Het veld wordt correct weergegeven in de formulierweergave, dus alles lijkt in orde tijdens het testen. Dan probeert iemand het als filter toe te voegen of het in een rapport op te nemen, en het werkt niet. Beslis vooraf of je het veld doorzoekbaar wilt maken. Als dat zo is, voeg dan store=True vanaf het begin toe.

Ontbrekende afhankelijkheid in @api.depends

Als je compute-methode partner_id.country_id leest, maar je decorator alleen partner_id vermeldt, zal het veld niet worden bijgewerkt wanneer het land op het partnerrecord verandert. Traceer het volledige pad van elke veldtoegang in je methode en vermeld elke stap expliciet in de decorator.

Stille fouten in de compute-methode

Als je compute-methode een uitzondering voor een record opwerpt, slaat Odoo stilletjes de herberekening voor dat record over en behoudt de vorige opgeslagen waarde. De fout kan in de serverlogs verschijnen, maar er wordt niets aan de gebruiker getoond. Dit kan leiden tot verouderde of onjuiste waarden die moeilijk te traceren zijn. Test altijd je compute-methode met records die ontbrekende of ongebruikelijke gegevens hebben.

Prestatievermindering bij grote datasets

Een compute-methode die goed werkt tijdens de ontwikkeling kan een ernstige bottleneck worden in productie als de tabel groeit tot tienduizenden records. Let op hoeveel databasequery's je compute-methode per record triggert. Een enkele extra query per record vermenigvuldigd met tienduizend records is tienduizend queries voor één opslaan-operatie.

Gebruik sudo() binnen compute-methoden

Het aanroepen van sudo() binnen een compute-methode om toegangrechten te omzeilen is een beveiligingsrisico. Als de berekende waarde gegevens blootlegt die de huidige gebruiker niet zou mogen zien, dan ondermijnt het retourneren ervan via een compute-methode het toestemmingsmodel van Odoo. Gebruik sudo() binnen compute-methoden alleen wanneer je de beveiligingsimplicaties zorgvuldig hebt overwogen.

Verwachten van onmiddellijke herberekening in alle contexten

In de meeste interactieve bewerkingen is herberekening synchroon. Maar tijdens batch-imports, achtergrondtaken of bepaalde ORM-bewerkingen met contextvlaggen, kan Odoo de herberekening uitstellen. Bouw geen bedrijfslogica die aanneemt dat de opgeslagen waarde altijd up-to-date is op het exacte moment dat een record wordt geschreven. Verifieer het gedrag in de specifieke context waarin je veld zal worden gebruikt.

Conclusie

Opgeslagen berekende velden zijn een van de meest nuttige hulpmiddelen bij het bouwen of uitbreiden van Odoo. Ze stellen je in staat om berekeningen te automatiseren, je gegevens consistent te houden en records doorzoekbaar en exporteerbaar te maken zonder enige handmatige inspanning van je gebruikers.

De belangrijkste punten om te onthouden:

• Gebruik store=True wanneer je wilt dat het veld doorzoekbaar, filterbaar of exporteerbaar is.
• Verklaar altijd alle afhankelijkheden in @api.depends(), inclusief cross-modelpaden.
• Houd compute-methoden snel en behandel randgevallen expliciet.
• Voor eenvoudige formules is Odoo Studio een snelle optie. Voor alles wat complexer is, schrijf Python.
• Plan voor initiële herberekening bij het implementeren in productie op grote tabellen.

Of je nu een nieuwe aangepaste module bouwt, een bestaand Odoo-model uitbreidt, of voor de eerste keer Odoo-veldtypen verkent, opgeslagen berekende velden zijn het waard om diepgaand te begrijpen. Ze bevinden zich op het snijpunt van de Odoo ORM, de database-laag en je bedrijfslogica.

Hulp Nodig Bij Je Odoo Implementatie?

Dasolo helpt bedrijven bij het implementeren, aanpassen en optimaliseren van Odoo voor een breed scala aan zakelijke behoeften. Of je nu berekende velden aan je datamodel wilt toevoegen, rapporten wilt opstellen die zijn gebaseerd op berekende waarden, of je Odoo-ontwikkeling verder wilt brengen, ons team heeft de ervaring om te helpen.

Neem contact met ons op als je ondersteuning nodig hebt bij je Odoo-project. We praten graag je gebruiksgeval door en vinden de juiste aanpak voor jouw bedrijf.