vendor/doctrine/orm/src/Internal/Hydration/SimpleObjectHydrator.php line 60

  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\Mapping\MappingException;
  10. use Doctrine\ORM\Query;
  11. use Exception;
  12. use RuntimeException;
  13. use ValueError;
  15. use function array_keys;
  16. use function array_search;
  17. use function count;
  18. use function in_array;
  19. use function key;
  20. use function reset;
  21. use function sprintf;
  23. class SimpleObjectHydrator extends AbstractHydrator
  24. {
  25.     use SQLResultCasing;
  27.     /** @var ClassMetadata */
  28.     private $class;
  30.     /**
  31.      * {@inheritDoc}
  32.      */
  33.     protected function prepare()
  34.     {
  35.         if (count($this->resultSetMapping()->aliasMap) !== 1) {
  36.             throw new RuntimeException('Cannot use SimpleObjectHydrator with a ResultSetMapping that contains more than one object result.');
  37.         }
  39.         if ($this->resultSetMapping()->scalarMappings) {
  40.             throw new RuntimeException('Cannot use SimpleObjectHydrator with a ResultSetMapping that contains scalar mappings.');
  41.         }
  43.         $this->class = $this->getClassMetadata(reset($this->resultSetMapping()->aliasMap));
  44.     }
  46.     /**
  47.      * {@inheritDoc}
  48.      */
  49.     protected function cleanup()
  50.     {
  51.         parent::cleanup();
  53.         $this->_uow->triggerEagerLoads();
  54.         $this->_uow->hydrationComplete();
  55.     }
  57.     /**
  58.      * {@inheritDoc}
  59.      */
  60.     protected function hydrateAllData()
  61.     {
  62.         $result = [];
  64.         while ($row = $this->statement()->fetchAssociative()) {
  65.             $this->hydrateRowData($row, $result);
  66.         }
  68.         $this->_em->getUnitOfWork()->triggerEagerLoads();
  70.         return $result;
  71.     }
  73.     /**
  74.      * {@inheritDoc}
  75.      */
  76.     protected function hydrateRowData(array $row, array &$result)
  77.     {
  78.         $entityName       = $this->class->name;
  79.         $data             = [];
  80.         $discrColumnValue = null;
  82.         // We need to find the correct entity class name if we have inheritance in resultset
  83.         if ($this->class->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  84.             $discrColumn     = $this->class->getDiscriminatorColumn();
  85.             $discrColumnName = $this->getSQLResultCasing($this->_platform, $discrColumn['name']);
  87.             // Find mapped discriminator column from the result set.
  88.             $metaMappingDiscrColumnName = array_search($discrColumnName, $this->resultSetMapping()->metaMappings, true);
  89.             if ($metaMappingDiscrColumnName) {
  90.                 $discrColumnName = $metaMappingDiscrColumnName;
  91.             }
  93.             if (! isset($row[$discrColumnName])) {
  94.                 throw HydrationException::missingDiscriminatorColumn(
  95.                     $entityName,
  96.                     $discrColumnName,
  97.                     key($this->resultSetMapping()->aliasMap)
  98.                 );
  99.             }
  101.             if ($row[$discrColumnName] === '') {
  102.                 throw HydrationException::emptyDiscriminatorValue(key(
  103.                     $this->resultSetMapping()->aliasMap
  104.                 ));
  105.             }
  107.             $discrMap = $this->class->discriminatorMap;
  109.             if (! isset($discrMap[$row[$discrColumnName]])) {
  110.                 throw HydrationException::invalidDiscriminatorValue($row[$discrColumnName], array_keys($discrMap));
  111.             }
  113.             $entityName       = $discrMap[$row[$discrColumnName]];
  114.             $discrColumnValue = $row[$discrColumnName];
  116.             unset($row[$discrColumnName]);
  117.         }
  119.         foreach ($row as $column => $value) {
  120.             // An ObjectHydrator should be used instead of SimpleObjectHydrator
  121.             if (isset($this->resultSetMapping()->relationMap[$column])) {
  122.                 throw new Exception(sprintf('Unable to retrieve association information for column "%s"', $column));
  123.             }
  125.             $cacheKeyInfo = $this->hydrateColumnInfo($column);
  127.             if (! $cacheKeyInfo) {
  128.                 continue;
  129.             }
  131.             // If we have inheritance in resultset, make sure the field belongs to the correct class
  132.             if (isset($cacheKeyInfo['discriminatorValues']) && ! in_array((string) $discrColumnValue, $cacheKeyInfo['discriminatorValues'], true)) {
  133.                 continue;
  134.             }
  136.             // Check if value is null before conversion (because some types convert null to something else)
  137.             $valueIsNull = $value === null;
  139.             // Convert field to a valid PHP value
  140.             if (isset($cacheKeyInfo['type'])) {
  141.                 $type  = $cacheKeyInfo['type'];
  142.                 $value = $type->convertToPHPValue($value, $this->_platform);
  143.             }
  145.             if ($value !== null && isset($cacheKeyInfo['enumType'])) {
  146.                 $originalValue = $value;
  147.                 try {
  148.                     $value = $this->buildEnum($originalValue, $cacheKeyInfo['enumType']);
  149.                 } catch (ValueError $e) {
  150.                     throw MappingException::invalidEnumValue(
  151.                         $entityName,
  152.                         $cacheKeyInfo['fieldName'],
  153.                         (string) $originalValue,
  154.                         $cacheKeyInfo['enumType'],
  155.                         $e
  156.                     );
  157.                 }
  158.             }
  160.             $fieldName = $cacheKeyInfo['fieldName'];
  162.             // Prevent overwrite in case of inherit classes using same property name (See AbstractHydrator)
  163.             if (! isset($data[$fieldName]) || ! $valueIsNull) {
  164.                 $data[$fieldName] = $value;
  165.             }
  166.         }
  168.         if (isset($this->_hints[Query::HINT_REFRESH_ENTITY])) {
  169.             $this->registerManaged($this->class, $this->_hints[Query::HINT_REFRESH_ENTITY], $data);
  170.         }
  172.         $uow    = $this->_em->getUnitOfWork();
  173.         $entity = $uow->createEntity($entityName, $data, $this->_hints);
  175.         $result[] = $entity;
  177.         if (isset($this->_hints[Query::HINT_INTERNAL_ITERATION]) && $this->_hints[Query::HINT_INTERNAL_ITERATION]) {
  178.             $this->_uow->hydrationComplete();
  179.         }
  180.     }
  181. }