vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/SimpleObjectHydrator.php line 58

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Internal\Hydration;
  7. use Doctrine\ORM\Internal\SQLResultCasing;
  8. use Doctrine\ORM\Mapping\ClassMetadata;
  9. use Doctrine\ORM\Query;
  10. use Exception;
  11. use RuntimeException;
  13. use function array_keys;
  14. use function array_search;
  15. use function count;
  16. use function in_array;
  17. use function key;
  18. use function reset;
  19. use function sprintf;
  21. class SimpleObjectHydrator extends AbstractHydrator
  22. {
  23.     use SQLResultCasing;
  25.     /** @var ClassMetadata */
  26.     private $class;
  28.     /**
  29.      * {@inheritdoc}
  30.      */
  31.     protected function prepare()
  32.     {
  33.         if (count($this->resultSetMapping()->aliasMap) !== 1) {
  34.             throw new RuntimeException('Cannot use SimpleObjectHydrator with a ResultSetMapping that contains more than one object result.');
  35.         }
  37.         if ($this->resultSetMapping()->scalarMappings) {
  38.             throw new RuntimeException('Cannot use SimpleObjectHydrator with a ResultSetMapping that contains scalar mappings.');
  39.         }
  41.         $this->class = $this->getClassMetadata(reset($this->resultSetMapping()->aliasMap));
  42.     }
  44.     /**
  45.      * {@inheritdoc}
  46.      */
  47.     protected function cleanup()
  48.     {
  49.         parent::cleanup();
  51.         $this->_uow->triggerEagerLoads();
  52.         $this->_uow->hydrationComplete();
  53.     }
  55.     /**
  56.      * {@inheritdoc}
  57.      */
  58.     protected function hydrateAllData()
  59.     {
  60.         $result = [];
  62.         while ($row = $this->statement()->fetchAssociative()) {
  63.             $this->hydrateRowData($row, $result);
  64.         }
  66.         $this->_em->getUnitOfWork()->triggerEagerLoads();
  68.         return $result;
  69.     }
  71.     /**
  72.      * {@inheritdoc}
  73.      */
  74.     protected function hydrateRowData(array $row, array &$result)
  75.     {
  76.         $entityName       = $this->class->name;
  77.         $data             = [];
  78.         $discrColumnValue = null;
  80.         // We need to find the correct entity class name if we have inheritance in resultset
  81.         if ($this->class->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  82.             $discrColumn     = $this->class->getDiscriminatorColumn();
  83.             $discrColumnName = $this->getSQLResultCasing($this->_platform, $discrColumn['name']);
  85.             // Find mapped discriminator column from the result set.
  86.             $metaMappingDiscrColumnName = array_search($discrColumnName, $this->resultSetMapping()->metaMappings, true);
  87.             if ($metaMappingDiscrColumnName) {
  88.                 $discrColumnName = $metaMappingDiscrColumnName;
  89.             }
  91.             if (! isset($row[$discrColumnName])) {
  92.                 throw HydrationException::missingDiscriminatorColumn(
  93.                     $entityName,
  94.                     $discrColumnName,
  95.                     key($this->resultSetMapping()->aliasMap)
  96.                 );
  97.             }
  99.             if ($row[$discrColumnName] === '') {
  100.                 throw HydrationException::emptyDiscriminatorValue(key(
  101.                     $this->resultSetMapping()->aliasMap
  102.                 ));
  103.             }
  105.             $discrMap = $this->class->discriminatorMap;
  107.             if (! isset($discrMap[$row[$discrColumnName]])) {
  108.                 throw HydrationException::invalidDiscriminatorValue($row[$discrColumnName], array_keys($discrMap));
  109.             }
  111.             $entityName       = $discrMap[$row[$discrColumnName]];
  112.             $discrColumnValue = $row[$discrColumnName];
  114.             unset($row[$discrColumnName]);
  115.         }
  117.         foreach ($row as $column => $value) {
  118.             // An ObjectHydrator should be used instead of SimpleObjectHydrator
  119.             if (isset($this->resultSetMapping()->relationMap[$column])) {
  120.                 throw new Exception(sprintf('Unable to retrieve association information for column "%s"', $column));
  121.             }
  123.             $cacheKeyInfo = $this->hydrateColumnInfo($column);
  125.             if (! $cacheKeyInfo) {
  126.                 continue;
  127.             }
  129.             // If we have inheritance in resultset, make sure the field belongs to the correct class
  130.             if (isset($cacheKeyInfo['discriminatorValues']) && ! in_array((string) $discrColumnValue, $cacheKeyInfo['discriminatorValues'], true)) {
  131.                 continue;
  132.             }
  134.             // Check if value is null before conversion (because some types convert null to something else)
  135.             $valueIsNull = $value === null;
  137.             // Convert field to a valid PHP value
  138.             if (isset($cacheKeyInfo['type'])) {
  139.                 $type  = $cacheKeyInfo['type'];
  140.                 $value = $type->convertToPHPValue($value, $this->_platform);
  141.             }
  143.             $fieldName = $cacheKeyInfo['fieldName'];
  145.             // Prevent overwrite in case of inherit classes using same property name (See AbstractHydrator)
  146.             if (! isset($data[$fieldName]) || ! $valueIsNull) {
  147.                 $data[$fieldName] = $value;
  148.             }
  149.         }
  151.         $uow    = $this->_em->getUnitOfWork();
  152.         $entity = $uow->createEntity($entityName, $data, $this->_hints);
  154.         $result[] = $entity;
  156.         if (isset($this->_hints[Query::HINT_INTERNAL_ITERATION]) && $this->_hints[Query::HINT_INTERNAL_ITERATION]) {
  157.             $this->_uow->hydrationComplete();
  158.         }
  159.     }
  160. }