vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/ObjectHydrator.php line 109

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Internal\Hydration;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Proxy\Proxy;
  9. use Doctrine\ORM\Mapping\ClassMetadata;
  10. use Doctrine\ORM\PersistentCollection;
  11. use Doctrine\ORM\Query;
  12. use Doctrine\ORM\UnitOfWork;
  14. use function array_fill_keys;
  15. use function array_keys;
  16. use function count;
  17. use function is_array;
  18. use function key;
  19. use function ltrim;
  20. use function spl_object_id;
  22. /**
  23.  * The ObjectHydrator constructs an object graph out of an SQL result set.
  24.  *
  25.  * Internal note: Highly performance-sensitive code.
  26.  */
  27. class ObjectHydrator extends AbstractHydrator
  28. {
  29.     /** @var mixed[] */
  30.     private $identifierMap = [];
  32.     /** @var mixed[] */
  33.     private $resultPointers = [];
  35.     /** @var mixed[] */
  36.     private $idTemplate = [];
  38.     /** @var int */
  39.     private $resultCounter = 0;
  41.     /** @var mixed[] */
  42.     private $rootAliases = [];
  44.     /** @var mixed[] */
  45.     private $initializedCollections = [];
  47.     /** @var mixed[] */
  48.     private $existingCollections = [];
  50.     /**
  51.      * {@inheritdoc}
  52.      */
  53.     protected function prepare()
  54.     {
  55.         if (! isset($this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD])) {
  56.             $this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD] = true;
  57.         }
  59.         foreach ($this->resultSetMapping()->aliasMap as $dqlAlias => $className) {
  60.             $this->identifierMap[$dqlAlias] = [];
  61.             $this->idTemplate[$dqlAlias]    = '';
  63.             // Remember which associations are "fetch joined", so that we know where to inject
  64.             // collection stubs or proxies and where not.
  65.             if (! isset($this->resultSetMapping()->relationMap[$dqlAlias])) {
  66.                 continue;
  67.             }
  69.             $parent = $this->resultSetMapping()->parentAliasMap[$dqlAlias];
  71.             if (! isset($this->resultSetMapping()->aliasMap[$parent])) {
  72.                 throw HydrationException::parentObjectOfRelationNotFound($dqlAlias, $parent);
  73.             }
  75.             $sourceClassName = $this->resultSetMapping()->aliasMap[$parent];
  76.             $sourceClass     = $this->getClassMetadata($sourceClassName);
  77.             $assoc           = $sourceClass->associationMappings[$this->resultSetMapping()->relationMap[$dqlAlias]];
  79.             $this->_hints['fetched'][$parent][$assoc['fieldName']] = true;
  81.             if ($assoc['type'] === ClassMetadata::MANY_TO_MANY) {
  82.                 continue;
  83.             }
  85.             // Mark any non-collection opposite sides as fetched, too.
  86.             if ($assoc['mappedBy']) {
  87.                 $this->_hints['fetched'][$dqlAlias][$assoc['mappedBy']] = true;
  89.                 continue;
  90.             }
  92.             // handle fetch-joined owning side bi-directional one-to-one associations
  93.             if ($assoc['inversedBy']) {
  94.                 $class        = $this->getClassMetadata($className);
  95.                 $inverseAssoc = $class->associationMappings[$assoc['inversedBy']];
  97.                 if (! ($inverseAssoc['type'] & ClassMetadata::TO_ONE)) {
  98.                     continue;
  99.                 }
  101.                 $this->_hints['fetched'][$dqlAlias][$inverseAssoc['fieldName']] = true;
  102.             }
  103.         }
  104.     }
  106.     /**
  107.      * {@inheritdoc}
  108.      */
  109.     protected function cleanup()
  110.     {
  111.         $eagerLoad = isset($this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD]) && $this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD] === true;
  113.         parent::cleanup();
  115.         $this->identifierMap          =
  116.         $this->initializedCollections =
  117.         $this->existingCollections    =
  118.         $this->resultPointers         = [];
  120.         if ($eagerLoad) {
  121.             $this->_uow->triggerEagerLoads();
  122.         }
  124.         $this->_uow->hydrationComplete();
  125.     }
  127.     protected function cleanupAfterRowIteration(): void
  128.     {
  129.         $this->identifierMap          =
  130.         $this->initializedCollections =
  131.         $this->existingCollections    =
  132.         $this->resultPointers         = [];
  133.     }
  135.     /**
  136.      * {@inheritdoc}
  137.      */
  138.     protected function hydrateAllData()
  139.     {
  140.         $result = [];
  142.         while ($row = $this->statement()->fetchAssociative()) {
  143.             $this->hydrateRowData($row, $result);
  144.         }
  146.         // Take snapshots from all newly initialized collections
  147.         foreach ($this->initializedCollections as $coll) {
  148.             $coll->takeSnapshot();
  149.         }
  151.         return $result;
  152.     }
  154.     /**
  155.      * Initializes a related collection.
  156.      *
  157.      * @param object $entity         The entity to which the collection belongs.
  158.      * @param string $fieldName      The name of the field on the entity that holds the collection.
  159.      * @param string $parentDqlAlias Alias of the parent fetch joining this collection.
  160.      */
  161.     private function initRelatedCollection(
  162.         $entity,
  163.         ClassMetadata $class,
  164.         string $fieldName,
  165.         string $parentDqlAlias
  166.     ): PersistentCollection {
  167.         $oid      = spl_object_id($entity);
  168.         $relation = $class->associationMappings[$fieldName];
  169.         $value    = $class->reflFields[$fieldName]->getValue($entity);
  171.         if ($value === null || is_array($value)) {
  172.             $value = new ArrayCollection((array) $value);
  173.         }
  175.         if (! $value instanceof PersistentCollection) {
  176.             $value = new PersistentCollection(
  177.                 $this->_em,
  178.                 $this->_metadataCache[$relation['targetEntity']],
  179.                 $value
  180.             );
  181.             $value->setOwner($entity, $relation);
  183.             $class->reflFields[$fieldName]->setValue($entity, $value);
  184.             $this->_uow->setOriginalEntityProperty($oid, $fieldName, $value);
  186.             $this->initializedCollections[$oid . $fieldName] = $value;
  187.         } elseif (
  188.             isset($this->_hints[Query::HINT_REFRESH]) ||
  189.             isset($this->_hints['fetched'][$parentDqlAlias][$fieldName]) &&
  190.              ! $value->isInitialized()
  191.         ) {
  192.             // Is already PersistentCollection, but either REFRESH or FETCH-JOIN and UNINITIALIZED!
  193.             $value->setDirty(false);
  194.             $value->setInitialized(true);
  195.             $value->unwrap()->clear();
  197.             $this->initializedCollections[$oid . $fieldName] = $value;
  198.         } else {
  199.             // Is already PersistentCollection, and DON'T REFRESH or FETCH-JOIN!
  200.             $this->existingCollections[$oid . $fieldName] = $value;
  201.         }
  203.         return $value;
  204.     }
  206.     /**
  207.      * Gets an entity instance.
  208.      *
  209.      * @param string $dqlAlias The DQL alias of the entity's class.
  210.      * @psalm-param array<string, mixed> $data     The instance data.
  211.      *
  212.      * @return object
  213.      *
  214.      * @throws HydrationException
  215.      */
  216.     private function getEntity(array $data, string $dqlAlias)
  217.     {
  218.         $className = $this->resultSetMapping()->aliasMap[$dqlAlias];
  220.         if (isset($this->resultSetMapping()->discriminatorColumns[$dqlAlias])) {
  221.             $fieldName = $this->resultSetMapping()->discriminatorColumns[$dqlAlias];
  223.             if (! isset($this->resultSetMapping()->metaMappings[$fieldName])) {
  224.                 throw HydrationException::missingDiscriminatorMetaMappingColumn($className, $fieldName, $dqlAlias);
  225.             }
  227.             $discrColumn = $this->resultSetMapping()->metaMappings[$fieldName];
  229.             if (! isset($data[$discrColumn])) {
  230.                 throw HydrationException::missingDiscriminatorColumn($className, $discrColumn, $dqlAlias);
  231.             }
  233.             if ($data[$discrColumn] === '') {
  234.                 throw HydrationException::emptyDiscriminatorValue($dqlAlias);
  235.             }
  237.             $discrMap           = $this->_metadataCache[$className]->discriminatorMap;
  238.             $discriminatorValue = (string) $data[$discrColumn];
  240.             if (! isset($discrMap[$discriminatorValue])) {
  241.                 throw HydrationException::invalidDiscriminatorValue($discriminatorValue, array_keys($discrMap));
  242.             }
  244.             $className = $discrMap[$discriminatorValue];
  246.             unset($data[$discrColumn]);
  247.         }
  249.         if (isset($this->_hints[Query::HINT_REFRESH_ENTITY], $this->rootAliases[$dqlAlias])) {
  250.             $this->registerManaged($this->_metadataCache[$className], $this->_hints[Query::HINT_REFRESH_ENTITY], $data);
  251.         }
  253.         $this->_hints['fetchAlias'] = $dqlAlias;
  255.         return $this->_uow->createEntity($className, $data, $this->_hints);
  256.     }
  258.     /**
  259.      * @psalm-param class-string $className
  260.      * @psalm-param array<string, mixed> $data
  261.      *
  262.      * @return mixed
  263.      */
  264.     private function getEntityFromIdentityMap(string $className, array $data)
  265.     {
  266.         // TODO: Abstract this code and UnitOfWork::createEntity() equivalent?
  267.         $class = $this->_metadataCache[$className];
  269.         if ($class->isIdentifierComposite) {
  270.             $idHash = '';
  272.             foreach ($class->identifier as $fieldName) {
  273.                 $idHash .= ' ' . (isset($class->associationMappings[$fieldName])
  274.                     ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']]
  275.                     : $data[$fieldName]);
  276.             }
  278.             return $this->_uow->tryGetByIdHash(ltrim($idHash), $class->rootEntityName);
  279.         } elseif (isset($class->associationMappings[$class->identifier[0]])) {
  280.             return $this->_uow->tryGetByIdHash($data[$class->associationMappings[$class->identifier[0]]['joinColumns'][0]['name']], $class->rootEntityName);
  281.         }
  283.         return $this->_uow->tryGetByIdHash($data[$class->identifier[0]], $class->rootEntityName);
  284.     }
  286.     /**
  287.      * Hydrates a single row in an SQL result set.
  288.      *
  289.      * @internal
  290.      * First, the data of the row is split into chunks where each chunk contains data
  291.      * that belongs to a particular component/class. Afterwards, all these chunks
  292.      * are processed, one after the other. For each chunk of class data only one of the
  293.      * following code paths is executed:
  294.      *
  295.      * Path A: The data chunk belongs to a joined/associated object and the association
  296.      *         is collection-valued.
  297.      * Path B: The data chunk belongs to a joined/associated object and the association
  298.      *         is single-valued.
  299.      * Path C: The data chunk belongs to a root result element/object that appears in the topmost
  300.      *         level of the hydrated result. A typical example are the objects of the type
  301.      *         specified by the FROM clause in a DQL query.
  302.      *
  303.      * @param mixed[] $row    The data of the row to process.
  304.      * @param mixed[] $result The result array to fill.
  305.      *
  306.      * @return void
  307.      */
  308.     protected function hydrateRowData(array $row, array &$result)
  309.     {
  310.         // Initialize
  311.         $id                 = $this->idTemplate; // initialize the id-memory
  312.         $nonemptyComponents = [];
  313.         // Split the row data into chunks of class data.
  314.         $rowData = $this->gatherRowData($row, $id, $nonemptyComponents);
  316.         // reset result pointers for each data row
  317.         $this->resultPointers = [];
  319.         // Hydrate the data chunks
  320.         foreach ($rowData['data'] as $dqlAlias => $data) {
  321.             $entityName = $this->resultSetMapping()->aliasMap[$dqlAlias];
  323.             if (isset($this->resultSetMapping()->parentAliasMap[$dqlAlias])) {
  324.                 // It's a joined result
  326.                 $parentAlias = $this->resultSetMapping()->parentAliasMap[$dqlAlias];
  327.                 // we need the $path to save into the identifier map which entities were already
  328.                 // seen for this parent-child relationship
  329.                 $path = $parentAlias . '.' . $dqlAlias;
  331.                 // We have a RIGHT JOIN result here. Doctrine cannot hydrate RIGHT JOIN Object-Graphs
  332.                 if (! isset($nonemptyComponents[$parentAlias])) {
  333.                     // TODO: Add special case code where we hydrate the right join objects into identity map at least
  334.                     continue;
  335.                 }
  337.                 $parentClass   = $this->_metadataCache[$this->resultSetMapping()->aliasMap[$parentAlias]];
  338.                 $relationField = $this->resultSetMapping()->relationMap[$dqlAlias];
  339.                 $relation      = $parentClass->associationMappings[$relationField];
  340.                 $reflField     = $parentClass->reflFields[$relationField];
  342.                 // Get a reference to the parent object to which the joined element belongs.
  343.                 if ($this->resultSetMapping()->isMixed && isset($this->rootAliases[$parentAlias])) {
  344.                     $objectClass  = $this->resultPointers[$parentAlias];
  345.                     $parentObject = $objectClass[key($objectClass)];
  346.                 } elseif (isset($this->resultPointers[$parentAlias])) {
  347.                     $parentObject = $this->resultPointers[$parentAlias];
  348.                 } else {
  349.                     // Parent object of relation not found, mark as not-fetched again
  350.                     $element = $this->getEntity($data, $dqlAlias);
  352.                     // Update result pointer and provide initial fetch data for parent
  353.                     $this->resultPointers[$dqlAlias]               = $element;
  354.                     $rowData['data'][$parentAlias][$relationField] = $element;
  356.                     // Mark as not-fetched again
  357.                     unset($this->_hints['fetched'][$parentAlias][$relationField]);
  358.                     continue;
  359.                 }
  361.                 $oid = spl_object_id($parentObject);
  363.                 // Check the type of the relation (many or single-valued)
  364.                 if (! ($relation['type'] & ClassMetadata::TO_ONE)) {
  365.                     // PATH A: Collection-valued association
  366.                     $reflFieldValue = $reflField->getValue($parentObject);
  368.                     if (isset($nonemptyComponents[$dqlAlias])) {
  369.                         $collKey = $oid . $relationField;
  370.                         if (isset($this->initializedCollections[$collKey])) {
  371.                             $reflFieldValue = $this->initializedCollections[$collKey];
  372.                         } elseif (! isset($this->existingCollections[$collKey])) {
  373.                             $reflFieldValue = $this->initRelatedCollection($parentObject, $parentClass, $relationField, $parentAlias);
  374.                         }
  376.                         $indexExists  = isset($this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]]);
  377.                         $index        = $indexExists ? $this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] : false;
  378.                         $indexIsValid = $index !== false ? isset($reflFieldValue[$index]) : false;
  380.                         if (! $indexExists || ! $indexIsValid) {
  381.                             if (isset($this->existingCollections[$collKey])) {
  382.                                 // Collection exists, only look for the element in the identity map.
  383.                                 $element = $this->getEntityFromIdentityMap($entityName, $data);
  384.                                 if ($element) {
  385.                                     $this->resultPointers[$dqlAlias] = $element;
  386.                                 } else {
  387.                                     unset($this->resultPointers[$dqlAlias]);
  388.                                 }
  389.                             } else {
  390.                                 $element = $this->getEntity($data, $dqlAlias);
  392.                                 if (isset($this->resultSetMapping()->indexByMap[$dqlAlias])) {
  393.                                     $indexValue = $row[$this->resultSetMapping()->indexByMap[$dqlAlias]];
  394.                                     $reflFieldValue->hydrateSet($indexValue, $element);
  395.                                     $this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] = $indexValue;
  396.                                 } else {
  397.                                     $reflFieldValue->hydrateAdd($element);
  398.                                     $reflFieldValue->last();
  399.                                     $this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] = $reflFieldValue->key();
  400.                                 }
  402.                                 // Update result pointer
  403.                                 $this->resultPointers[$dqlAlias] = $element;
  404.                             }
  405.                         } else {
  406.                             // Update result pointer
  407.                             $this->resultPointers[$dqlAlias] = $reflFieldValue[$index];
  408.                         }
  409.                     } elseif (! $reflFieldValue) {
  410.                         $this->initRelatedCollection($parentObject, $parentClass, $relationField, $parentAlias);
  411.                     } elseif ($reflFieldValue instanceof PersistentCollection && $reflFieldValue->isInitialized() === false) {
  412.                         $reflFieldValue->setInitialized(true);
  413.                     }
  414.                 } else {
  415.                     // PATH B: Single-valued association
  416.                     $reflFieldValue = $reflField->getValue($parentObject);
  418.                     if (! $reflFieldValue || isset($this->_hints[Query::HINT_REFRESH]) || ($reflFieldValue instanceof Proxy && ! $reflFieldValue->__isInitialized())) {
  419.                         // we only need to take action if this value is null,
  420.                         // we refresh the entity or its an uninitialized proxy.
  421.                         if (isset($nonemptyComponents[$dqlAlias])) {
  422.                             $element = $this->getEntity($data, $dqlAlias);
  423.                             $reflField->setValue($parentObject, $element);
  424.                             $this->_uow->setOriginalEntityProperty($oid, $relationField, $element);
  425.                             $targetClass = $this->_metadataCache[$relation['targetEntity']];
  427.                             if ($relation['isOwningSide']) {
  428.                                 // TODO: Just check hints['fetched'] here?
  429.                                 // If there is an inverse mapping on the target class its bidirectional
  430.                                 if ($relation['inversedBy']) {
  431.                                     $inverseAssoc = $targetClass->associationMappings[$relation['inversedBy']];
  432.                                     if ($inverseAssoc['type'] & ClassMetadata::TO_ONE) {
  433.                                         $targetClass->reflFields[$inverseAssoc['fieldName']]->setValue($element, $parentObject);
  434.                                         $this->_uow->setOriginalEntityProperty(spl_object_id($element), $inverseAssoc['fieldName'], $parentObject);
  435.                                     }
  436.                                 } elseif ($parentClass === $targetClass && $relation['mappedBy']) {
  437.                                     // Special case: bi-directional self-referencing one-one on the same class
  438.                                     $targetClass->reflFields[$relationField]->setValue($element, $parentObject);
  439.                                 }
  440.                             } else {
  441.                                 // For sure bidirectional, as there is no inverse side in unidirectional mappings
  442.                                 $targetClass->reflFields[$relation['mappedBy']]->setValue($element, $parentObject);
  443.                                 $this->_uow->setOriginalEntityProperty(spl_object_id($element), $relation['mappedBy'], $parentObject);
  444.                             }
  446.                             // Update result pointer
  447.                             $this->resultPointers[$dqlAlias] = $element;
  448.                         } else {
  449.                             $this->_uow->setOriginalEntityProperty($oid, $relationField, null);
  450.                             $reflField->setValue($parentObject, null);
  451.                         }
  452.                         // else leave $reflFieldValue null for single-valued associations
  453.                     } else {
  454.                         // Update result pointer
  455.                         $this->resultPointers[$dqlAlias] = $reflFieldValue;
  456.                     }
  457.                 }
  458.             } else {
  459.                 // PATH C: Its a root result element
  460.                 $this->rootAliases[$dqlAlias] = true; // Mark as root alias
  461.                 $entityKey                    = $this->resultSetMapping()->entityMappings[$dqlAlias] ?: 0;
  463.                 // if this row has a NULL value for the root result id then make it a null result.
  464.                 if (! isset($nonemptyComponents[$dqlAlias])) {
  465.                     if ($this->resultSetMapping()->isMixed) {
  466.                         $result[] = [$entityKey => null];
  467.                     } else {
  468.                         $result[] = null;
  469.                     }
  471.                     $resultKey = $this->resultCounter;
  472.                     ++$this->resultCounter;
  473.                     continue;
  474.                 }
  476.                 // check for existing result from the iterations before
  477.                 if (! isset($this->identifierMap[$dqlAlias][$id[$dqlAlias]])) {
  478.                     $element = $this->getEntity($data, $dqlAlias);
  480.                     if ($this->resultSetMapping()->isMixed) {
  481.                         $element = [$entityKey => $element];
  482.                     }
  484.                     if (isset($this->resultSetMapping()->indexByMap[$dqlAlias])) {
  485.                         $resultKey = $row[$this->resultSetMapping()->indexByMap[$dqlAlias]];
  487.                         if (isset($this->_hints['collection'])) {
  488.                             $this->_hints['collection']->hydrateSet($resultKey, $element);
  489.                         }
  491.                         $result[$resultKey] = $element;
  492.                     } else {
  493.                         $resultKey = $this->resultCounter;
  494.                         ++$this->resultCounter;
  496.                         if (isset($this->_hints['collection'])) {
  497.                             $this->_hints['collection']->hydrateAdd($element);
  498.                         }
  500.                         $result[] = $element;
  501.                     }
  503.                     $this->identifierMap[$dqlAlias][$id[$dqlAlias]] = $resultKey;
  505.                     // Update result pointer
  506.                     $this->resultPointers[$dqlAlias] = $element;
  507.                 } else {
  508.                     // Update result pointer
  509.                     $index                           = $this->identifierMap[$dqlAlias][$id[$dqlAlias]];
  510.                     $this->resultPointers[$dqlAlias] = $result[$index];
  511.                     $resultKey                       = $index;
  512.                 }
  513.             }
  515.             if (isset($this->_hints[Query::HINT_INTERNAL_ITERATION]) && $this->_hints[Query::HINT_INTERNAL_ITERATION]) {
  516.                 $this->_uow->hydrationComplete();
  517.             }
  518.         }
  520.         if (! isset($resultKey)) {
  521.             $this->resultCounter++;
  522.         }
  524.         // Append scalar values to mixed result sets
  525.         if (isset($rowData['scalars'])) {
  526.             if (! isset($resultKey)) {
  527.                 $resultKey = isset($this->resultSetMapping()->indexByMap['scalars'])
  528.                     ? $row[$this->resultSetMapping()->indexByMap['scalars']]
  529.                     : $this->resultCounter - 1;
  530.             }
  532.             foreach ($rowData['scalars'] as $name => $value) {
  533.                 $result[$resultKey][$name] = $value;
  534.             }
  535.         }
  537.         // Append new object to mixed result sets
  538.         if (isset($rowData['newObjects'])) {
  539.             if (! isset($resultKey)) {
  540.                 $resultKey = $this->resultCounter - 1;
  541.             }
  543.             $scalarCount = (isset($rowData['scalars']) ? count($rowData['scalars']) : 0);
  545.             foreach ($rowData['newObjects'] as $objIndex => $newObject) {
  546.                 $class = $newObject['class'];
  547.                 $args  = $newObject['args'];
  548.                 $obj   = $class->newInstanceArgs($args);
  550.                 if ($scalarCount === 0 && count($rowData['newObjects']) === 1) {
  551.                     $result[$resultKey] = $obj;
  553.                     continue;
  554.                 }
  556.                 $result[$resultKey][$objIndex] = $obj;
  557.             }
  558.         }
  559.     }
  561.     /**
  562.      * When executed in a hydrate() loop we may have to clear internal state to
  563.      * decrease memory consumption.
  564.      *
  565.      * @param mixed $eventArgs
  566.      *
  567.      * @return void
  568.      */
  569.     public function onClear($eventArgs)
  570.     {
  571.         parent::onClear($eventArgs);
  573.         $aliases = array_keys($this->identifierMap);
  575.         $this->identifierMap = array_fill_keys($aliases, []);
  576.     }
  577. }