One2many-velden in Odoo: De Complete Gids

Introductie

Als je ooit een verkooporder in Odoo hebt geopend en onder de klantgegevens een lijst met orderregels zag, dan heb je het One2many-veld al in actie gezien. Het is een van de hoekstenen van het Odoo-datamodel: een elegante manier om één hoofdrecord te koppelen aan een verzameling subrecords, en iets dat je snel terugziet in formulieren en rapporten.

In deze gids leggen we in duidelijke stappen uit wat het One2many-veld precies betekent binnen de Odoo ORM, hoe het technisch in elkaar zit, wanneer je het best gebruikt en hoe je het toevoegt — zowel via Odoo Studio zonder code als door velden rechtstreeks in Python te definiëren.

Of je nu een eindgebruiker bent die wil begrijpen hoe data is gestructureerd, of een ontwikkelaar die op zoek is naar praktische instructies: dit artikel geeft je de kerninzichten die je nodig hebt om met vertrouwen met One2many-relaties te werken.

Wat is het One2many-veld in Odoo

Een One2many-veld is een relationeel veldtype binnen Odoo waarmee één ouderrecord is verbonden met meerdere kindrecords uit een ander model.

In de praktijk betekent dat bijvoorbeeld: één klant kan meerdere facturen hebben, één verkooporder meerdere orderregels, en één project meerdere taken. Het ouderrecord presenteert als het ware een lijst met alle bijbehorende subitems via dat One2many-kader.

In de Odoo-gebruikersinterface verschijnt een One2many meestal als een ingesloten lijst in een formulier. Die tabel maakt het mogelijk om regels toe te voegen, wijzigen of verwijderen zonder de ouderkaart te verlaten — wat het een van de meest zichtbare en meest gebruikte patronen in Odoo maakt.

Verschil met andere relationele velden

Odoo kent drie klassieke relationele veldtypes in de ORM:

• Many2one: een record verwijst naar één record in een ander model (bijv. een verkooporder naar één klant).
• One2many: één record is gekoppeld aan meerdere records in een ander model (bijv. een verkooporder met veel orderregels).
• Many2many: records aan beide zijden kunnen met meerdere tegenhangers zijn verbonden (bijv. een product gekoppeld aan meerdere tags, en een tag aan meerdere producten).

Je kiest One2many wanneer elk kind maar bij één ouder hoort. Als een kindrecord door meerdere ouders moet gedeeld worden, is Many2many doorgaans de juiste keuze.

Een belangrijk technisch kenmerk van One2many is dat het zelf geen kolom in de oudertabel toevoegt. Het is een virtuele view die de bijbehorende kindrecords ophaalt op basis van een Many2one-kolom die op het kindmodel bestaat.

Hoe het veld precies werkt

Concreet wordt er in de database niets op de oudertabel opgeslagen voor het One2many: de relaties staan in de kindtabel, waar iedere rij een foreign key heeft die naar de ouder verwijst.

Dit is een fundamenteel principe van de Odoo ORM: elk One2many-veld heeft altijd een corresponderend Many2one-veld op het gerelateerde model. One2many is in wezen een omgekeerde zoekactie: Odoo selecteert alle kindrecords waarvan die Many2one naar het huidige ouder-ID verwijst.

De koppeling tussen One2many en Many2one

Bij het definiëren van een One2many in Python geef je twee cruciale parameters op:

• comodel_name: het model waarin de kindrecords staan.
• inverse_name: de naam van het Many2one-veld op het kindmodel dat terugverwijst naar de ouder.

Een eenvoudig voorbeeld uit een maatwerkmodule illustreert hoe een servicecontract meerdere deliverables kan groeperen.

deliverable_ids = fields.One2many(
    comodel_name='service.deliverable',
    inverse_name='contract_id',
    string='Deliverables'
)

In dit voorbeeld is contract_id een Many2one op service.deliverable die naar het contract verwijst. Zonder die Many2one bestaat de One2many niet — het inverse veld moet eerst aanwezig zijn.

Wat er in de database gebeurt

In de database worden One2many-relaties niet in de oudertabel bewaard; de gegevens staan in de kindtabel, waar elke child‑rij een verwijzing heeft naar het ouderrecord.

Wanneer Odoo een ouderrecord laadt om het One2many-veld te tonen, voert het een query uit die alle child-rijen selecteert waarvan de foreign key overeenkomt met het huidige ouder-ID. De ORM regelt dat automatisch.

Daarom wordt One2many gezien als een Python-veld dat geen extra databasekolom toevoegt: het is een dynamische weergave van gerelateerde records.

Wanneer bedrijven het gebruiken

One2many komt in heel Odoo voor omdat het natuurlijke ouder-kindrelaties modelleert. Hieronder vijf concrete voorbeelden uit veelvoorkomende bedrijfsprocessen.

1. Verkooporders en orderregels

In de Verkoopmodule koppelt het veld order_line_ids op sale.order naar sale.order.line. Elke regel bevat product, hoeveelheid, prijs en korting. Gebruikers kunnen regels direct in het verkooporderformulier beheren zonder te schakelen van scherm.

2. Facturen en factuurlijnen

In Boekhouding gebruikt account.move een One2many naar account.move.line om factuurlijnen te beheren. De factuur als ouder verzamelt de totalen van al zijn childregels.

3. Projecten en taken

In Project geeft een One2many op project.project alle taken weer die bij dat project horen. In het formulier kan dit als lijst, kanban of Gantt verschijnen, maar de onderliggende relatie is steeds hetzelfde.

4. Contacten en subcontacten

Het model res.partner heeft child_ids om werknemers of contactpersonen van een bedrijf te tonen. Elk subcontact heeft op zijn beurt een parent_id Many2one die naar het bedrijf wijst.

5. Maatwerk voor service of productie

Bij maatwerk is One2many vaak de voor de hand liggende keuze wanneer één record een verzameling subitems bezit, bijvoorbeeld een onderhoudsopdracht met meerdere gebruikte onderdelen, een cursus met meerdere lesdata of een contract met meerdere deliverables.

Die flexibiliteit maakt One2many onmisbaar bij het modelleren van bedrijfsprocessen in Odoo en bij het bouwen van sectorgerichte oplossingen.

Een One2many-veld maken of aanpassen

Er zijn twee veelgebruikte methodes om een One2many toe te voegen: via Odoo Studio (geen code) of door velden in Python te definiëren (ontwikkelaars).

Werken met Odoo Studio

In Studio kun je niet zomaar vanaf de ouderkant een One2many toevoegen zonder dat de Many2one op het kindmodel eerst bestaat. De One2many vereist die inverse Many2one als basis.

Het aanbevolen stappenplan in Studio is dan ook helder:

1. Open eerst het kindmodel in Studio en voeg daar een Many2one-veld toe dat naar het oudermodel wijst.
2. Sla die wijziging op en ga terug naar het oudermodel in Studio.
3. Voeg vervolgens een nieuw veld toe, kies "One2many" en wijs het gerelateerde model en het inverse-veld aan.
4. Na deze stappen verschijnt het One2many als een ingesloten lijst in je formulierweergave.

Voor veel zakelijke gebruikers is dit de eenvoudigste manier om One2many-relaties te configureren zonder code; Studio-velden gedragen zich dan hetzelfde als velden die in Python zijn gedefinieerd.

Werken met Python in een custom module

Ontwikkelaars definiëren One2many-velden in Python wanneer ze volledige controle willen over gedrag, naming en eventuele domain-filters. Een volledig voorbeeld laat de correcte volgorde en attributen zien.

from odoo import fields, models

class ServiceContract(models.Model):
    _name = 'service.contract'
    _description = 'Service Contract'

    name = fields.Char(string='Contract Name', required=True)
    deliverable_ids = fields.One2many(
        comodel_name='service.deliverable',
        inverse_name='contract_id',
        string='Deliverables'
    )


class ServiceDeliverable(models.Model):
    _name = 'service.deliverable'
    _description = 'Service Deliverable'

    contract_id = fields.Many2one(
        comodel_name='service.contract',
        string='Contract',
        ondelete='cascade'
    )
    name = fields.Char(string='Description', required=True)

Let op: het Many2one-veld (contract_id) moet op het childmodel staan voordat je in de One2many het inverse_name naar dat veld verwijst. De namen moeten exact overeenkomen.

Het veld aanmaken via de XML-RPC API

Als je velden programmatisch beheert (bijv. bij migraties of geautomatiseerde deployments), kun je One2many-velden ook via de XML-RPC API aanmaken door het model ir.model.fields te gebruiken. Het principe blijft hetzelfde: eerst de Many2one, daarna de One2many met de relation_field die naar de Many2one verwijst.

Deze werkwijze is handig bij multi‑omgeving beheer of wanneer je Odoo-velden via scripts wilt uitrollen.

Aanbevolen werkwijzen

Op basis van implementaties bij klanten zijn er enkele best practices die het verschil maken bij het gebruik van One2many-velden.

• Maak altijd eerst de Many2one aan. Zonder het inverseveld op het childmodel kan de One2many niet bestaan — dit geldt in Studio, in Python en via de API.
• Gebruik de conventie met het achtervoegsel _ids voor One2many-velden (bijv. line_ids, task_ids). Dat geeft meteen aan dat het om een recordset gaat en maakt de code duidelijker.
• Stel waar relevant ondelete='cascade' in op de Many2one. Als childrecords automatisch moeten verdwijnen bij het verwijderen van de ouder, voorkomt dit dat er verweesde records in de database achterblijven.
• Houd de ingesloten lijst overzichtelijk. Toon alleen de meest relevante kolommen: te veel velden maken het formulier traag en onoverzichtelijk. Gebruik optionele kolommen voor minder belangrijke gegevens.
• Gebruik domain-filters om te beperken welke childrecords zichtbaar zijn. Dit is nuttig wanneer een childmodel door meerdere parents wordt gedeeld en je alleen een subset wil tonen.
• Let op grote aantallen childrecords. Als een ouder duizenden childregels kan hebben, laad die dan niet allemaal in één formulier. Overweeg paginering, een aparte lijstweergave of een beperkte weergave met een knop naar het volledige overzicht.

Veelvoorkomende valkuilen

Veelvoorkomende fouten en misverstanden bij One2many

Het vergeten van het inverse Many2one

De meest gemaakte fout is proberen een One2many te creëren zonder eerst het bijbehorende Many2one op het childmodel te definiëren. Odoo geeft dan een foutmelding: controleer altijd of het inverse_name exact bestaat op het childmodel.

Verkeerde schrijfwijze bij updates

Bij het updaten van One2many-velden via Python of de API moet je de speciale Odoo-commando‑tuple syntax gebruiken; je kunt niet simpelweg een Python-lijst toewijzen.

• (0, 0, values_dict) maakt een nieuw childrecord aan.
• (1, child_id, values_dict) werkt een bestaand childrecord bij.
• (2, child_id, 0) verwijdert een bestaand childrecord (delete).
• (4, child_id, 0) voegt een bestaand record toe aan de relatie.
• (5, 0, 0) maakt alle childrecords los van de ouder (unlink zonder te deleten).

Een toewijzing zoals record.line_ids = [1, 2, 3] zal niet correct werken; gebruik de command-tupels voor betrouwbare updates.

One2many en Many2many verwarren

Verwar One2many niet met Many2many: One2many impliceert dat elk childrecord slechts bij één ouder hoort. Heb je een scenario waarin hetzelfde childrecord aan meerdere ouders gelinkt moet zijn, gebruik dan Many2many om duplicatie en dataconsistentieproblemen te voorkomen.

Prestatieproblemen met grote sublijsten

Formulieren met honderden of duizenden regels in een One2many vertragen pagina‑laden flink. Dit komt vaak voor bij factuurlijnen of stockbewegingen. Gebruik limieten, paginering of aparte views voor grote datasets.

Verweesde records na verwijderen

Als je een ouder verwijdert zonder ondelete='cascade' op de Many2one in te stellen, blijven childrecords mogelijk bestaan met een lege of ongeldige verwijzing. Dat leidt na verloop van tijd tot rommel in de database en onverwachte fouten in views en rapporten. Bepaal altijd een duidelijke verwijderstrategie bij het ontwerpen van je datamodel.

Samenvatting

Het One2many-veld is fundamenteel voor het Odoo-datamodel. Het ondersteunt kernfunctionaliteit zoals orderregels, factuurlijnen en projecttaken. Zodra je de relatie met de inverse Many2one begrijpt, wordt een groot deel van Odoo’s interne structuur veel overzichtelijker en eenvoudiger aan te passen.

Of je Odoo nu configureert voor je organisatie, aanpast met Studio of een maatwerkmodule bouwt, One2many is een gereedschap dat je vaak zult gebruiken. Goed ontwerp, juiste naming en het vermijden van veelgemaakte fouten besparen veel tijd en voorkomen dataverlies.

Wil je meer technische uitleg en praktijkvoorbeelden over Odoo-velden en API’s? Bekijk dan de overige artikelen in de Odoo Data & API-collectie voor verdieping en voorbeelden.

Hulp nodig met je Odoo-implementatie?

Dasolo begeleidt bedrijven bij het implementeren, aanpassen en optimaliseren van Odoo zodat het precies aansluit op hun bedrijfsvoering. Of je nu hulp nodig hebt bij het datamodel, het bouwen van maatwerkmodules of het verbeteren van je bestaande Odoo-installatie: ons team staat klaar.

Heb je vragen over je Odoo-project of wil je bespreken hoe je je data het beste structureert, neem contact met ons op— we helpen je graag verder.