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

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\ORM\Internal\Hydration;
  22. use Doctrine\ORM\UnitOfWork;
  23. use PDO;
  24. use Doctrine\ORM\Mapping\ClassMetadata;
  25. use Doctrine\ORM\PersistentCollection;
  26. use Doctrine\ORM\Query;
  27. use Doctrine\Common\Collections\ArrayCollection;
  28. use Doctrine\ORM\Proxy\Proxy;
  30. /**
  31.  * The ObjectHydrator constructs an object graph out of an SQL result set.
  32.  *
  33.  * Internal note: Highly performance-sensitive code.
  34.  *
  35.  * @since  2.0
  36.  * @author Roman Borschel <roman@code-factory.org>
  37.  * @author Guilherme Blanco <guilhermeblanoc@hotmail.com>
  38.  * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
  39.  */
  40. class ObjectHydrator extends AbstractHydrator
  41. {
  42.     /**
  43.      * @var array
  44.      */
  45.     private $identifierMap = [];
  47.     /**
  48.      * @var array
  49.      */
  50.     private $resultPointers = [];
  52.     /**
  53.      * @var array
  54.      */
  55.     private $idTemplate = [];
  57.     /**
  58.      * @var integer
  59.      */
  60.     private $resultCounter = 0;
  62.     /**
  63.      * @var array
  64.      */
  65.     private $rootAliases = [];
  67.     /**
  68.      * @var array
  69.      */
  70.     private $initializedCollections = [];
  72.     /**
  73.      * @var array
  74.      */
  75.     private $existingCollections = [];
  77.     /**
  78.      * {@inheritdoc}
  79.      */
  80.     protected function prepare()
  81.     {
  82.         if ( ! isset($this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD])) {
  83.             $this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD] = true;
  84.         }
  86.         foreach ($this->_rsm->aliasMap as $dqlAlias => $className) {
  87.             $this->identifierMap[$dqlAlias] = [];
  88.             $this->idTemplate[$dqlAlias]    = '';
  90.             // Remember which associations are "fetch joined", so that we know where to inject
  91.             // collection stubs or proxies and where not.
  92.             if ( ! isset($this->_rsm->relationMap[$dqlAlias])) {
  93.                 continue;
  94.             }
  96.             $parent = $this->_rsm->parentAliasMap[$dqlAlias];
  98.             if ( ! isset($this->_rsm->aliasMap[$parent])) {
  99.                 throw HydrationException::parentObjectOfRelationNotFound($dqlAlias, $parent);
  100.             }
  102.             $sourceClassName = $this->_rsm->aliasMap[$parent];
  103.             $sourceClass     = $this->getClassMetadata($sourceClassName);
  104.             $assoc           = $sourceClass->associationMappings[$this->_rsm->relationMap[$dqlAlias]];
  106.             $this->_hints['fetched'][$parent][$assoc['fieldName']] = true;
  108.             if ($assoc['type'] === ClassMetadata::MANY_TO_MANY) {
  109.                 continue;
  110.             }
  112.             // Mark any non-collection opposite sides as fetched, too.
  113.             if ($assoc['mappedBy']) {
  114.                 $this->_hints['fetched'][$dqlAlias][$assoc['mappedBy']] = true;
  116.                 continue;
  117.             }
  119.             // handle fetch-joined owning side bi-directional one-to-one associations
  120.             if ($assoc['inversedBy']) {
  121.                 $class        = $this->getClassMetadata($className);
  122.                 $inverseAssoc = $class->associationMappings[$assoc['inversedBy']];
  124.                 if ( ! ($inverseAssoc['type'] & ClassMetadata::TO_ONE)) {
  125.                     continue;
  126.                 }
  128.                 $this->_hints['fetched'][$dqlAlias][$inverseAssoc['fieldName']] = true;
  129.             }
  130.         }
  131.     }
  133.     /**
  134.      * {@inheritdoc}
  135.      */
  136.     protected function cleanup()
  137.     {
  138.         $eagerLoad = (isset($this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD])) && $this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD] == true;
  140.         parent::cleanup();
  142.         $this->identifierMap =
  143.         $this->initializedCollections =
  144.         $this->existingCollections =
  145.         $this->resultPointers = [];
  147.         if ($eagerLoad) {
  148.             $this->_uow->triggerEagerLoads();
  149.         }
  151.         $this->_uow->hydrationComplete();
  152.     }
  154.     /**
  155.      * {@inheritdoc}
  156.      */
  157.     protected function hydrateAllData()
  158.     {
  159.         $result = [];
  161.         while ($row = $this->_stmt->fetch(PDO::FETCH_ASSOC)) {
  162.             $this->hydrateRowData($row, $result);
  163.         }
  165.         // Take snapshots from all newly initialized collections
  166.         foreach ($this->initializedCollections as $coll) {
  167.             $coll->takeSnapshot();
  168.         }
  170.         return $result;
  171.     }
  173.     /**
  174.      * Initializes a related collection.
  175.      *
  176.      * @param object        $entity         The entity to which the collection belongs.
  177.      * @param ClassMetadata $class
  178.      * @param string        $fieldName      The name of the field on the entity that holds the collection.
  179.      * @param string        $parentDqlAlias Alias of the parent fetch joining this collection.
  180.      *
  181.      * @return \Doctrine\ORM\PersistentCollection
  182.      */
  183.     private function initRelatedCollection($entity, $class, $fieldName, $parentDqlAlias)
  184.     {
  185.         $oid      = spl_object_hash($entity);
  186.         $relation = $class->associationMappings[$fieldName];
  187.         $value    = $class->reflFields[$fieldName]->getValue($entity);
  189.         if ($value === null || is_array($value)) {
  190.             $value = new ArrayCollection((array) $value);
  191.         }
  193.         if ( ! $value instanceof PersistentCollection) {
  194.             $value = new PersistentCollection(
  195.                 $this->_em, $this->_metadataCache[$relation['targetEntity']], $value
  196.             );
  197.             $value->setOwner($entity, $relation);
  199.             $class->reflFields[$fieldName]->setValue($entity, $value);
  200.             $this->_uow->setOriginalEntityProperty($oid, $fieldName, $value);
  202.             $this->initializedCollections[$oid . $fieldName] = $value;
  203.         } else if (
  204.             isset($this->_hints[Query::HINT_REFRESH]) ||
  205.             isset($this->_hints['fetched'][$parentDqlAlias][$fieldName]) &&
  206.              ! $value->isInitialized()
  207.         ) {
  208.             // Is already PersistentCollection, but either REFRESH or FETCH-JOIN and UNINITIALIZED!
  209.             $value->setDirty(false);
  210.             $value->setInitialized(true);
  211.             $value->unwrap()->clear();
  213.             $this->initializedCollections[$oid . $fieldName] = $value;
  214.         } else {
  215.             // Is already PersistentCollection, and DON'T REFRESH or FETCH-JOIN!
  216.             $this->existingCollections[$oid . $fieldName] = $value;
  217.         }
  219.         return $value;
  220.     }
  222.     /**
  223.      * Gets an entity instance.
  224.      *
  225.      * @param array  $data     The instance data.
  226.      * @param string $dqlAlias The DQL alias of the entity's class.
  227.      *
  228.      * @return object The entity.
  229.      *
  230.      * @throws HydrationException
  231.      */
  232.     private function getEntity(array $data, $dqlAlias)
  233.     {
  234.         $className = $this->_rsm->aliasMap[$dqlAlias];
  236.         if (isset($this->_rsm->discriminatorColumns[$dqlAlias])) {
  237.             $fieldName = $this->_rsm->discriminatorColumns[$dqlAlias];
  239.             if ( ! isset($this->_rsm->metaMappings[$fieldName])) {
  240.                 throw HydrationException::missingDiscriminatorMetaMappingColumn($className, $fieldName, $dqlAlias);
  241.             }
  243.             $discrColumn = $this->_rsm->metaMappings[$fieldName];
  245.             if ( ! isset($data[$discrColumn])) {
  246.                 throw HydrationException::missingDiscriminatorColumn($className, $discrColumn, $dqlAlias);
  247.             }
  249.             if ($data[$discrColumn] === "") {
  250.                 throw HydrationException::emptyDiscriminatorValue($dqlAlias);
  251.             }
  253.             $discrMap = $this->_metadataCache[$className]->discriminatorMap;
  254.             $discriminatorValue = (string) $data[$discrColumn];
  256.             if ( ! isset($discrMap[$discriminatorValue])) {
  257.                 throw HydrationException::invalidDiscriminatorValue($discriminatorValue, array_keys($discrMap));
  258.             }
  260.             $className = $discrMap[$discriminatorValue];
  262.             unset($data[$discrColumn]);
  263.         }
  265.         if (isset($this->_hints[Query::HINT_REFRESH_ENTITY]) && isset($this->rootAliases[$dqlAlias])) {
  266.             $this->registerManaged($this->_metadataCache[$className], $this->_hints[Query::HINT_REFRESH_ENTITY], $data);
  267.         }
  269.         $this->_hints['fetchAlias'] = $dqlAlias;
  271.         return $this->_uow->createEntity($className, $data, $this->_hints);
  272.     }
  274.     /**
  275.      * @param string $className
  276.      * @param array  $data
  277.      *
  278.      * @return mixed
  279.      */
  280.     private function getEntityFromIdentityMap($className, array $data)
  281.     {
  282.         // TODO: Abstract this code and UnitOfWork::createEntity() equivalent?
  283.         $class = $this->_metadataCache[$className];
  285.         /* @var $class ClassMetadata */
  286.         if ($class->isIdentifierComposite) {
  287.             $idHash = '';
  289.             foreach ($class->identifier as $fieldName) {
  290.                 $idHash .= ' ' . (isset($class->associationMappings[$fieldName])
  291.                     ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']]
  292.                     : $data[$fieldName]);
  293.             }
  295.             return $this->_uow->tryGetByIdHash(ltrim($idHash), $class->rootEntityName);
  296.         } else if (isset($class->associationMappings[$class->identifier[0]])) {
  297.             return $this->_uow->tryGetByIdHash($data[$class->associationMappings[$class->identifier[0]]['joinColumns'][0]['name']], $class->rootEntityName);
  298.         }
  300.         return $this->_uow->tryGetByIdHash($data[$class->identifier[0]], $class->rootEntityName);
  301.     }
  303.     /**
  304.      * Hydrates a single row in an SQL result set.
  305.      *
  306.      * @internal
  307.      * First, the data of the row is split into chunks where each chunk contains data
  308.      * that belongs to a particular component/class. Afterwards, all these chunks
  309.      * are processed, one after the other. For each chunk of class data only one of the
  310.      * following code paths is executed:
  311.      *
  312.      * Path A: The data chunk belongs to a joined/associated object and the association
  313.      *         is collection-valued.
  314.      * Path B: The data chunk belongs to a joined/associated object and the association
  315.      *         is single-valued.
  316.      * Path C: The data chunk belongs to a root result element/object that appears in the topmost
  317.      *         level of the hydrated result. A typical example are the objects of the type
  318.      *         specified by the FROM clause in a DQL query.
  319.      *
  320.      * @param array $row    The data of the row to process.
  321.      * @param array $result The result array to fill.
  322.      *
  323.      * @return void
  324.      */
  325.     protected function hydrateRowData(array $row, array &$result)
  326.     {
  327.         // Initialize
  328.         $id = $this->idTemplate; // initialize the id-memory
  329.         $nonemptyComponents = [];
  330.         // Split the row data into chunks of class data.
  331.         $rowData = $this->gatherRowData($row, $id, $nonemptyComponents);
  333.         // reset result pointers for each data row
  334.         $this->resultPointers = [];
  336.         // Hydrate the data chunks
  337.         foreach ($rowData['data'] as $dqlAlias => $data) {
  338.             $entityName = $this->_rsm->aliasMap[$dqlAlias];
  340.             if (isset($this->_rsm->parentAliasMap[$dqlAlias])) {
  341.                 // It's a joined result
  343.                 $parentAlias = $this->_rsm->parentAliasMap[$dqlAlias];
  344.                 // we need the $path to save into the identifier map which entities were already
  345.                 // seen for this parent-child relationship
  346.                 $path = $parentAlias . '.' . $dqlAlias;
  348.                 // We have a RIGHT JOIN result here. Doctrine cannot hydrate RIGHT JOIN Object-Graphs
  349.                 if ( ! isset($nonemptyComponents[$parentAlias])) {
  350.                     // TODO: Add special case code where we hydrate the right join objects into identity map at least
  351.                     continue;
  352.                 }
  354.                 $parentClass    = $this->_metadataCache[$this->_rsm->aliasMap[$parentAlias]];
  355.                 $relationField  = $this->_rsm->relationMap[$dqlAlias];
  356.                 $relation       = $parentClass->associationMappings[$relationField];
  357.                 $reflField      = $parentClass->reflFields[$relationField];
  359.                 // Get a reference to the parent object to which the joined element belongs.
  360.                 if ($this->_rsm->isMixed && isset($this->rootAliases[$parentAlias])) {
  361.                     $objectClass = $this->resultPointers[$parentAlias];
  362.                     $parentObject = $objectClass[key($objectClass)];
  363.                 } else if (isset($this->resultPointers[$parentAlias])) {
  364.                     $parentObject = $this->resultPointers[$parentAlias];
  365.                 } else {
  366.                     // Parent object of relation not found, mark as not-fetched again
  367.                     $element = $this->getEntity($data, $dqlAlias);
  369.                     // Update result pointer and provide initial fetch data for parent
  370.                     $this->resultPointers[$dqlAlias] = $element;
  371.                     $rowData['data'][$parentAlias][$relationField] = $element;
  373.                     // Mark as not-fetched again
  374.                     unset($this->_hints['fetched'][$parentAlias][$relationField]);
  375.                     continue;
  376.                 }
  378.                 $oid = spl_object_hash($parentObject);
  380.                 // Check the type of the relation (many or single-valued)
  381.                 if ( ! ($relation['type'] & ClassMetadata::TO_ONE)) {
  382.                     // PATH A: Collection-valued association
  383.                     $reflFieldValue = $reflField->getValue($parentObject);
  385.                     if (isset($nonemptyComponents[$dqlAlias])) {
  386.                         $collKey = $oid . $relationField;
  387.                         if (isset($this->initializedCollections[$collKey])) {
  388.                             $reflFieldValue = $this->initializedCollections[$collKey];
  389.                         } else if ( ! isset($this->existingCollections[$collKey])) {
  390.                             $reflFieldValue = $this->initRelatedCollection($parentObject, $parentClass, $relationField, $parentAlias);
  391.                         }
  393.                         $indexExists    = isset($this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]]);
  394.                         $index          = $indexExists ? $this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] : false;
  395.                         $indexIsValid   = $index !== false ? isset($reflFieldValue[$index]) : false;
  397.                         if ( ! $indexExists || ! $indexIsValid) {
  398.                             if (isset($this->existingCollections[$collKey])) {
  399.                                 // Collection exists, only look for the element in the identity map.
  400.                                 if ($element = $this->getEntityFromIdentityMap($entityName, $data)) {
  401.                                     $this->resultPointers[$dqlAlias] = $element;
  402.                                 } else {
  403.                                     unset($this->resultPointers[$dqlAlias]);
  404.                                 }
  405.                             } else {
  406.                                 $element = $this->getEntity($data, $dqlAlias);
  408.                                 if (isset($this->_rsm->indexByMap[$dqlAlias])) {
  409.                                     $indexValue = $row[$this->_rsm->indexByMap[$dqlAlias]];
  410.                                     $reflFieldValue->hydrateSet($indexValue, $element);
  411.                                     $this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] = $indexValue;
  412.                                 } else {
  413.                                     $reflFieldValue->hydrateAdd($element);
  414.                                     $reflFieldValue->last();
  415.                                     $this->identifierMap[$path][$id[$parentAlias]][$id[$dqlAlias]] = $reflFieldValue->key();
  416.                                 }
  417.                                 // Update result pointer
  418.                                 $this->resultPointers[$dqlAlias] = $element;
  419.                             }
  420.                         } else {
  421.                             // Update result pointer
  422.                             $this->resultPointers[$dqlAlias] = $reflFieldValue[$index];
  423.                         }
  424.                     } else if ( ! $reflFieldValue) {
  425.                         $this->initRelatedCollection($parentObject, $parentClass, $relationField, $parentAlias);
  426.                     } else if ($reflFieldValue instanceof PersistentCollection && $reflFieldValue->isInitialized() === false) {
  427.                         $reflFieldValue->setInitialized(true);
  428.                     }
  430.                 } else {
  431.                     // PATH B: Single-valued association
  432.                     $reflFieldValue = $reflField->getValue($parentObject);
  434.                     if ( ! $reflFieldValue || isset($this->_hints[Query::HINT_REFRESH]) || ($reflFieldValue instanceof Proxy && !$reflFieldValue->__isInitialized__)) {
  435.                         // we only need to take action if this value is null,
  436.                         // we refresh the entity or its an uninitialized proxy.
  437.                         if (isset($nonemptyComponents[$dqlAlias])) {
  438.                             $element = $this->getEntity($data, $dqlAlias);
  439.                             $reflField->setValue($parentObject, $element);
  440.                             $this->_uow->setOriginalEntityProperty($oid, $relationField, $element);
  441.                             $targetClass = $this->_metadataCache[$relation['targetEntity']];
  443.                             if ($relation['isOwningSide']) {
  444.                                 // TODO: Just check hints['fetched'] here?
  445.                                 // If there is an inverse mapping on the target class its bidirectional
  446.                                 if ($relation['inversedBy']) {
  447.                                     $inverseAssoc = $targetClass->associationMappings[$relation['inversedBy']];
  448.                                     if ($inverseAssoc['type'] & ClassMetadata::TO_ONE) {
  449.                                         $targetClass->reflFields[$inverseAssoc['fieldName']]->setValue($element, $parentObject);
  450.                                         $this->_uow->setOriginalEntityProperty(spl_object_hash($element), $inverseAssoc['fieldName'], $parentObject);
  451.                                     }
  452.                                 } else if ($parentClass === $targetClass && $relation['mappedBy']) {
  453.                                     // Special case: bi-directional self-referencing one-one on the same class
  454.                                     $targetClass->reflFields[$relationField]->setValue($element, $parentObject);
  455.                                 }
  456.                             } else {
  457.                                 // For sure bidirectional, as there is no inverse side in unidirectional mappings
  458.                                 $targetClass->reflFields[$relation['mappedBy']]->setValue($element, $parentObject);
  459.                                 $this->_uow->setOriginalEntityProperty(spl_object_hash($element), $relation['mappedBy'], $parentObject);
  460.                             }
  461.                             // Update result pointer
  462.                             $this->resultPointers[$dqlAlias] = $element;
  463.                         } else {
  464.                             $this->_uow->setOriginalEntityProperty($oid, $relationField, null);
  465.                             $reflField->setValue($parentObject, null);
  466.                         }
  467.                         // else leave $reflFieldValue null for single-valued associations
  468.                     } else {
  469.                         // Update result pointer
  470.                         $this->resultPointers[$dqlAlias] = $reflFieldValue;
  471.                     }
  472.                 }
  473.             } else {
  474.                 // PATH C: Its a root result element
  475.                 $this->rootAliases[$dqlAlias] = true; // Mark as root alias
  476.                 $entityKey = $this->_rsm->entityMappings[$dqlAlias] ?: 0;
  478.                 // if this row has a NULL value for the root result id then make it a null result.
  479.                 if ( ! isset($nonemptyComponents[$dqlAlias]) ) {
  480.                     if ($this->_rsm->isMixed) {
  481.                         $result[] = [$entityKey => null];
  482.                     } else {
  483.                         $result[] = null;
  484.                     }
  485.                     $resultKey = $this->resultCounter;
  486.                     ++$this->resultCounter;
  487.                     continue;
  488.                 }
  490.                 // check for existing result from the iterations before
  491.                 if ( ! isset($this->identifierMap[$dqlAlias][$id[$dqlAlias]])) {
  492.                     $element = $this->getEntity($data, $dqlAlias);
  494.                     if ($this->_rsm->isMixed) {
  495.                         $element = [$entityKey => $element];
  496.                     }
  498.                     if (isset($this->_rsm->indexByMap[$dqlAlias])) {
  499.                         $resultKey = $row[$this->_rsm->indexByMap[$dqlAlias]];
  501.                         if (isset($this->_hints['collection'])) {
  502.                             $this->_hints['collection']->hydrateSet($resultKey, $element);
  503.                         }
  505.                         $result[$resultKey] = $element;
  506.                     } else {
  507.                         $resultKey = $this->resultCounter;
  508.                         ++$this->resultCounter;
  510.                         if (isset($this->_hints['collection'])) {
  511.                             $this->_hints['collection']->hydrateAdd($element);
  512.                         }
  514.                         $result[] = $element;
  515.                     }
  517.                     $this->identifierMap[$dqlAlias][$id[$dqlAlias]] = $resultKey;
  519.                     // Update result pointer
  520.                     $this->resultPointers[$dqlAlias] = $element;
  522.                 } else {
  523.                     // Update result pointer
  524.                     $index = $this->identifierMap[$dqlAlias][$id[$dqlAlias]];
  525.                     $this->resultPointers[$dqlAlias] = $result[$index];
  526.                     $resultKey = $index;
  527.                 }
  528.             }
  530.             if (isset($this->_hints[Query::HINT_INTERNAL_ITERATION]) && $this->_hints[Query::HINT_INTERNAL_ITERATION]) {
  531.                 $this->_uow->hydrationComplete();
  532.             }
  533.         }
  535.         if ( ! isset($resultKey) ) {
  536.             $this->resultCounter++;
  537.         }
  539.         // Append scalar values to mixed result sets
  540.         if (isset($rowData['scalars'])) {
  541.             if ( ! isset($resultKey) ) {
  542.                 $resultKey = (isset($this->_rsm->indexByMap['scalars']))
  543.                     ? $row[$this->_rsm->indexByMap['scalars']]
  544.                     : $this->resultCounter - 1;
  545.             }
  547.             foreach ($rowData['scalars'] as $name => $value) {
  548.                 $result[$resultKey][$name] = $value;
  549.             }
  550.         }
  552.         // Append new object to mixed result sets
  553.         if (isset($rowData['newObjects'])) {
  554.             if ( ! isset($resultKey) ) {
  555.                 $resultKey = $this->resultCounter - 1;
  556.             }
  559.             $scalarCount = (isset($rowData['scalars'])? count($rowData['scalars']): 0);
  561.             foreach ($rowData['newObjects'] as $objIndex => $newObject) {
  562.                 $class  = $newObject['class'];
  563.                 $args   = $newObject['args'];
  564.                 $obj    = $class->newInstanceArgs($args);
  566.                 if ($scalarCount == 0 && count($rowData['newObjects']) == 1 ) {
  567.                     $result[$resultKey] = $obj;
  569.                     continue;
  570.                 }
  572.                 $result[$resultKey][$objIndex] = $obj;
  573.             }
  574.         }
  575.     }
  577.     /**
  578.      * When executed in a hydrate() loop we may have to clear internal state to
  579.      * decrease memory consumption.
  580.      *
  581.      * @param mixed $eventArgs
  582.      *
  583.      * @return void
  584.      */
  585.     public function onClear($eventArgs)
  586.     {
  587.         parent::onClear($eventArgs);
  589.         $aliases             = array_keys($this->identifierMap);
  591.         $this->identifierMap = array_fill_keys($aliases, []);
  592.     }
  593. }