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

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. }