Introduzione
Se hai mai aperto un Ordine di Vendita in Odoo e hai visto l’elenco delle righe sotto i dati cliente, hai già incrociato il campo One2many in azione. È uno dei mattoni della struttura dati di Odoo e, per chi lavora con personalizzazioni o sviluppo, saperlo gestire è fondamentale.
Questa guida descrive che cos’è il campo One2many, il suo ruolo nell’ORM di Odoo, quando conviene usarlo e come crearlo sia tramite Odoo Studio che scrivendo direttamente il codice Python.
Che tu sia un utente business che vuole comprendere la struttura dei propri dati o uno sviluppatore in cerca di un riferimento pratico, troverai qui le informazioni essenziali per lavorare con questo tipo di relazione.
Cos’è il campo One2many in Odoo
Il campo One2many è un campo relazionale che collega un record “padre” a più record “figli” appartenenti a un altro modello, rappresentando quindi relazioni uno-a-molti nella base dati di Odoo.
È semplice da immaginare: un Cliente può avere molte Fatture; un Ordine può contenere più Righe d’Ordine; un Progetto può includere numerose Attività. Il record padre mantiene la relazione verso i figli tramite il campo One2many.
Nell’interfaccia Odoo il One2many si vede spesso come una lista incorporata all’interno della vista form: una tabella inline che permette di aggiungere, modificare o rimuovere righe senza abbandonare il form principale — un pattern estremamente usato nell’esperienza utente di Odoo.
Differenze rispetto agli altri campi relazionali
Nell’ORM di Odoo esistono tre tipologie principali di campi relazionali: Many2one, One2many e Many2many.
- Many2one: un singolo record punta a un record di un altro modello (per esempio un Ordine di Vendita punta a un Cliente).
- One2many: un singolo record è collegato a più record di un altro modello (per esempio un Ordine di Vendita con molte Righe d’Ordine).
- Many2many: più record su entrambi i lati sono collegati tra loro (per esempio Prodotti e Tag, dove ogni Tag può essere associato a più Prodotti e viceversa).
Usa One2many quando ogni record figlio appartiene soltanto a un singolo padre. Se il figlio deve essere condiviso tra più padri, allora la scelta corretta è Many2many.
Una caratteristica chiave del One2many è che non memorizza fisicamente i dati nella tabella del padre: è un campo virtuale che recupera i dati dal modello figlio tramite un campo Many2one inverso.
Come funziona il campo
A livello di database, il One2many non aggiunge colonne alla tabella del padre. I riferimenti sono memorizzati nella tabella del figlio, dove ogni riga contiene la chiave esterna verso il padre.
Questo è un principio fondamentale dell’ORM di Odoo: ogni One2many ha un corrispondente Many2one nel modello correlato. Il One2many funziona come una ricerca inversa: Odoo seleziona tutte le righe figlie il cui Many2one punta all’ID del padre corrente.
La relazione tra One2many e Many2one
Quando si dichiara un campo One2many in Python è necessario indicare due parametri principali.
- comodel_name: il nome del modello che contiene i record figli.
- inverse_name: il nome del campo Many2one presente sul modello figlio che punta indietro al padre.
Ecco un esempio pratico tratto da un modulo personalizzato che collega un Contratto di Servizio a più Deliverable.
deliverable_ids = fields.One2many(
comodel_name='service.deliverable',
inverse_name='contract_id',
string='Deliverables'
)In questo caso contract_id è il Many2one definito sul modello service.deliverable che rimanda al contratto. Senza quel Many2one il One2many non può funzionare.
Cosa avviene nel database
Nel database Odoo non vengono create colonne aggiuntive nella tabella del padre per il One2many: i dati sono presenti nella tabella del modello figlio, con una colonna FK che punta all’ID del padre.
Quando Odoo carica il record padre per mostrare il One2many, esegue una query per trovare tutte le righe nella tabella figlia la cui chiave esterna corrisponde all’ID del padre. L’ORM si occupa automaticamente di questa operazione.
Per questo motivo il One2many è considerato un campo che non modifica lo schema della tabella padre, ma offre una vista computata dei record correlati.
Casi d’uso aziendali
Esempi pratici d’uso del One2many
1. Ordini di Vendita e Righe d’Ordine
Nel modulo Vendite l’ordine usa un campo One2many (es. order_line_ids) per raccogliere le righe d’ordine (sale.order.line). Ogni riga contiene prodotto, quantità, prezzo unitario e sconto; l’utente aggiunge o rimuove righe direttamente dal form dell’ordine.
2. Fatture e Righe di Fattura
In Contabilità il modello account.move gestisce le righe di fattura mediante un One2many verso account.move.line. La fattura padre aggrega i totali calcolati sulle righe figlie.
3. Progetti e Attività
Il modulo Progetti mostra le Attività collegate a un Progetto tramite One2many; la vista può presentarsi come lista, kanban o diagramma di Gantt, ma la relazione sottostante è sempre la stessa.
4. Contatti e Sotto-contatti
Il modello res.partner utilizza child_ids per elencare i contatti collegati a una azienda. Ogni sub-contact possiede un parent_id Many2one che punta alla società principale.
5. Modelli personalizzati per servizi o produzione
Nei moduli custom il One2many è la scelta naturale ogni qualvolta un record “possiede” una lista di sotto-elementi: una richiesta di manutenzione con più ricambi, un corso con più date di lezione, o un contratto con più deliverable.
Questa versatilità rende il One2many centrale nella modellazione dati e nelle personalizzazioni verticali di Odoo per diversi settori.
Creare o personalizzare il campo
Metodi per creare un One2many in Odoo
Si possono definire One2many senza codice tramite Odoo Studio oppure programmaticamente scrivendo il campo in un modulo Python.
Uso di Odoo Studio
In Studio non puoi aggiungere direttamente un One2many dal selettore del modello padre perché serve prima che esista il Many2one sul modello figlio.
- Il flusso consigliato in Studio è semplice: apri il modello figlio e aggiungi un campo Many2one che punti al modello padre.
- Dopo aver salvato il Many2one, torna al modello padre in Studio.
- Aggiungi un nuovo campo di tipo One2many: Studio ti chiederà di scegliere il modello correlato e il campo inverse (il Many2one).
- Il One2many apparirà quindi come lista incorporata nella vista form del padre.
Per molti utenti business questo è il modo più rapido per creare relazioni uno-a-molti senza scrivere codice: i campi creati con Studio si comportano come quelli definiti in Python.
Uso del codice Python in un modulo custom
Per gli sviluppatori, definire il One2many in Python permette controllo totale su nome, comportamento e filtri di dominio. Di seguito un esempio completo.
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)Ricorda che il campo Many2one (contract_id) deve essere definito sul modello figlio prima: l’inverse_name nel One2many deve corrispondere esattamente al nome del Many2one.
Creare il campo tramite API XML-RPC
Se gestisci i campi del database programmaticamente puoi usare l’API XML-RPC su ir.model.fields. Anche qui vale la regola d’oro: crea prima il Many2one e poi il One2many specificando il parametro relation_field che punta al nome del Many2one.
Questa strada è utile per automatizzare creazioni di campi su più ambienti o per orchestrare personalizzazioni via script.
Buone pratiche
Buone pratiche raccolte dall’esperienza
- Crea sempre prima il Many2one. Un One2many non può esistere senza il campo inverso sul modello figlio, sia che tu usi Studio, codice o API.
- Usa il suffisso
_idsper i nomi dei campi One2many. È la convenzione Odoo che segnala chiaramente che il campo restituisce un recordset (es.line_ids,task_ids). - Imposta
ondelete='cascade'quando i figli devono essere eliminati insieme al padre: così eviti di lasciare record orfani nella base dati. - Mantieni la lista incorporata snella: mostra solo le colonne più rilevanti. Troppe colonne appesantiscono la vista; usa attributi opzionali per campi secondari che gli utenti possono attivare.
- Applica filtri di dominio per limitare i record visualizzati. Questo è utile quando lo stesso modello figlio viene usato da più modelli padre e serve isolare le righe pertinenti.
- Gestisci con attenzione i grandi insiemi di righe. Se un padre può avere migliaia di figli evita di caricarli tutti nella vista form: valuta paginazione o una vista list separata.
Errori comuni
Errori più frequenti con il One2many
Dimenticare il Many2one inverso
L’errore più comune è definire un One2many senza aver creato il corrispondente Many2one sul modello figlio. Odoo segnalerà l’errore: verifica sempre che l’inverse_name indicato esista davvero.
Sintassi di scrittura errata
Per aggiornare un One2many via codice o API devi usare la sintassi dei tuple di comando di Odoo: non puoi assegnare una semplice lista Python al campo.
- (0, 0, values_dict) per creare un nuovo record figlio.
- (1, child_id, values_dict) per aggiornare un record figlio esistente.
- (2, child_id, 0) per eliminare un record figlio esistente.
- (4, child_id, 0) per aggiungere un record figlio già esistente alla relazione.
- (5, 0, 0) per scollegare tutti i figli dal padre (senza cancellarli).
Provare a fare qualcosa come record.line_ids = [1, 2, 3] non funzionerà: bisogna usare i comandi adeguati dell’ORM.
Confondere One2many con Many2many
Ricorda: One2many implica che ogni figlio appartiene a un solo padre. Se serve che un figlio sia associato a più padri, scegli Many2many; usare One2many in quel caso costringerebbe a duplicare i record, compromettendo l’integrità dei dati.
Problemi di performance con sotto-liste grandi
Liste One2many con centinaia o migliaia di righe rallentano il caricamento delle pagine — problema comune in contabilità o magazzino. Applica limiti alle viste o rimanda l’utente a una lista separata per dataset molto grandi.
Record orfani dopo eliminazioni
Se cancelli un padre senza avere ondelete='cascade' sul Many2one del figlio, i figli possono restare con riferimenti nulli o incoerenti. Nel tempo questo crea confusione e bug in report e viste: definisci sempre una policy di cancellazione chiara.
Conclusione
Il One2many è un elemento fondamentale dell’ORM e del modello dati di Odoo. Alimenta funzionalità chiave come righe d’ordine, righe di fattura e attività di progetto: comprenderne il funzionamento e la relazione con il Many2one rende molto più semplice leggere ed estendere Odoo.
Sia che tu stia configurando Odoo per la tua azienda, personalizzando tramite Studio o sviluppando un modulo da zero, il One2many sarà uno degli strumenti più usati. Sapere quando impiegarlo, come definirlo correttamente e come evitare gli errori comuni ti farà risparmiare tempo e problemi futuri.
Se cerchi altri tutorial su campi Odoo e guide tecniche, dai un’occhiata agli altri articoli della raccolta Odoo Data & API.
Hai bisogno di supporto per la tua implementazione Odoo?
Dasolo supporta le aziende nell’implementazione, personalizzazione e ottimizzazione di Odoo per adattarlo ai processi specifici. Se ti serve aiuto nella progettazione del modello dati, nello sviluppo di moduli custom o nel migliorare la tua configurazione attuale, il nostro team è a disposizione.
Se hai domande sul tuo progetto Odoo o vuoi confrontarti su come strutturare al meglio i dati, contattaci. Siamo a disposizione per aiutarti.