The document describes various data structures and processes used in an ORM (object-relational mapper) system. The key points are: 1. The registry maps model names to model classes and holds metadata. It returns model class instances from browse() which reflect model definitions. 2. The record cache stores field values for quick access and is prefetched and invalidated based on changes. 3. Fields to write collects updates and flushes multiple records with the same updates in a single SQL query to minimize writes. 4. Fields to compute delays computations by tracking which records need recomputation and coordinating with the cache and writes. 5. Field triggers determine what to recompute or invalidate in the

2. Implementation requirements
● Be correct
● Be secure
● Be efficient
○ Use scalable algorithms
○ Use few and efficient SQL queries

3. Key data structures
● Registry
● Record cache
● Fields to write
● Fields to compute
● Field triggers

4. Registry
● Goal: map model_name to model_class
● model_class should reflect model definitions
● browse() returns an instance of model_class
● Also holds metadata

5. Model definitions
class Foo0(models.Model):
_name = 'foo'
...
class Foo1(models.Model):
_inherit = 'foo'
...
class Foo2(models.Model):
_inherit = 'foo'
...
Model classes
class foo(Foo2, Foo1, Foo0, Base):
_name = 'foo'

6. class Foo0(models.Model):
_name = 'foo'
...
class Bar0(models.AbstractModel):
_name = 'bar'
...
class Foo1(models.Model):
_name = 'foo'
_inherit = ['bar', 'foo']
...
class bar(Bar0, Base):
_name = 'bar'
class foo(Foo1, bar, Foo0, Base):
_name = 'foo'
Model definitions Model classes

7. Registry setup
● Determine fields by introspection
● Add custom fields
● Add _inherits fields
● Setup fields (parameters, depends, ...)

8. Registry
● Challenges:
○ Getting the model classes right
○ Performance of setup

9. Record cache
● Goal: augmented database cache
● Stores field values
● Accessible on environment

10. Record cache prefetching
First iteration:
● Look up the cache → nothing
● Fetch field on record:
○ Look up record._prefetch_ids for
missing values → all ids
○ If field is a column, fetch all columns
○ Invoke records._read(fields)
● Look up the cache → value
Next iterations:
● Look up the cache → value
records = model.browse(ids)
for record in records:
print(record.name)

11. Record cache
● Access N records: 1 + N dict lookups
● Update N records: 1 + N dict updates
● Invalidate N records: 1 + N dict deletions
{field: {record_id: value}}

12. Record cache (context-dependent
fields)
● Access N records: 2 + N dict lookups
● Update N records: 2 + N dict updates
● Invalidate N records: 1 + K * N dict deletions
{field: {ctx_key: {record_id: value}}}

13. Record cache
● Challenge: cache consistency
● When things change:
○ invalidate
○ update

14. Fields to write
● Goal: minimize UPDATE queries
● Stores column values
● Accessible on the environment

15. Fields to write
● write() collects updates until...
● flush() makes actual database updates
○ At most 1 UPDATE per record
○ Group records with the same UPDATE
{model_name: {record_id: {field_name: value}}}

16. Fields to write
● Challenge: database consistency
● flush() is automatically called by search(), read(),
read_group()
● Manual SQL queries requires explicit flush()

17. Fields to compute
● Goal: delay computations
● For computed stored fields only
● Accessible on environment
{field: set(ids)}

18. Fields to compute (stored)
def __get__(self, record, owner):
if record.id in tocompute.get(self, ()):
self.compute_value(record.browse(tocompute[self]))
try:
return record.env.cache.get(record, self)
except CacheMiss:
if self.store:
record._in_cache_without(self)._fetch(self)
elif self.compute:
self.compute_value(record._in_cache_without(self))
else:
...
return record.env.cache.get(record, self)

19. Fields to compute (non-stored)
def __get__(self, record, owner):
if record.id in tocompute.get(self, ()):
self.compute_value(record.browse(tocompute[self]))
try:
return record.env.cache.get(record, self)
except CacheMiss:
if self.store:
record._in_cache_without(self)._fetch(self)
elif self.compute:
self.compute_value(record._in_cache_without(self))
else:
...
return record.env.cache.get(record, self)

20. Fields to compute
● flush() first accesses fields to compute
○ Compute and assign values (to write)
○ Perform UPDATE queries
● Challenge: managing cache with fields to compute

21. Field triggers
● Goal: when modifying records, determine what to:
○ mark to compute, or
○ invalidate from cache
● Based on field dependencies

22. Field triggers
class Order(models.Model):
@api.depends('discount', 'line_ids.subtotal')
def _compute_total(self):
...
class OrderLine(models.Model):
@api.depends('price', 'quantity')
def _compute_subtotal(self):
...
line_ids line_ids
subtotal
order_id
price
quantity
subtotal
totaltotal
discount
line_ids
total
...
...

23. Fields triggers
def modified(self, fnames):
tree = merge(
field_triggers[self._fields[fname]]
for fname in fnames
)
self._modified_triggers(tree)
def _modified_triggers(self, tree):
if self:
for field in tree.root:
mark_to_compute_or_invalidate(field, self)
for field, subtree in tree.children:
records = inverse(field, self)
records._modified_triggers(subtree)

24. Field triggers
● Challenges:
○ Building the trigger trees
○ Performance of inversing dependencies

25. Thank You