1. `copy_cache` in `models.py` recursively copies the caches to environment, 
2. which in
```python
def _compute_related(self, records):
        """ Compute the related field ``self`` on ``records``. """
        others = records.sudo() if self.related_sudo else records
        if records.env != others.env:
            copy_cache(records - records.filtered('id'), others.env)
        values = list(others)
        for name in self.related[:-1]:
            values = [first(value[name]) for value in values]
        for record, value in zip(records, values):
            record[self.name] = value[self.related_field.name]
```
3. copies failing cache values that have been produce previously by this line:

`models.py : def _prefetch_field()`
```python

        try:
            # THIS ONE
            result = records.read([f.name for f in fs], load='_classic_write')
        except AccessError:
            # not all records may be accessible, try with only current record
            result = self.read([f.name for f in fs], load='_classic_write')
```
I checked it's exactly the same `FailedValue` object, which is later accessed without intent (not refreshed) by the fact that the buggy environment is copied to sudo (and not refreshed).


odoo/fields.py
Sparse fields have a very small probability of being not null. Therefore
        many such fields can be serialized compactly into a common location, the
        latter being a so-called "serialized" field.
        :param sparse: the name of the field where the value of this field must
            be stored.
        .. _field-incremental-definition:
        .. rubric:: Incremental definition
        A field is defined as class attribute on a model class. If the model
        is extended (see :class:`~odoo.models.Model`), one can also extend
        the field definition by redefining a field with the same name and same
        type on the subclass. In that case, the attributes of the field are
        taken from the parent class and overridden by the ones given in
        subclasses.
        For instance, the second class below only adds a tooltip on the field
        ``state``::
            class First(models.Model):
                _name = 'foo'
                state = fields.Selection([...], required=True)
            class Second(models.Model):
                _inherit = 'foo'
                state = fields.Selection(help="Blah blah blah")
    """
    __metaclass__ = MetaField
    type = None                         
    relational = False                  
    translate = False                   
    column_type = None                  
    column_format = '%s'                
    _slots = {
        'args': EMPTY_DICT,