vendor/doctrine/orm/src/Internal/Hydration/AbstractHydrator.php line 240

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Internal\Hydration;
  7. use BackedEnum;
  8. use Doctrine\DBAL\Driver\ResultStatement;
  9. use Doctrine\DBAL\ForwardCompatibility\Result as ForwardCompatibilityResult;
  10. use Doctrine\DBAL\Platforms\AbstractPlatform;
  11. use Doctrine\DBAL\Result;
  12. use Doctrine\DBAL\Types\Type;
  13. use Doctrine\Deprecations\Deprecation;
  14. use Doctrine\ORM\EntityManagerInterface;
  15. use Doctrine\ORM\Events;
  16. use Doctrine\ORM\Mapping\ClassMetadata;
  17. use Doctrine\ORM\Query\ResultSetMapping;
  18. use Doctrine\ORM\Tools\Pagination\LimitSubqueryWalker;
  19. use Doctrine\ORM\UnitOfWork;
  20. use Generator;
  21. use LogicException;
  22. use ReflectionClass;
  23. use TypeError;
  25. use function array_map;
  26. use function array_merge;
  27. use function count;
  28. use function end;
  29. use function get_debug_type;
  30. use function in_array;
  31. use function is_array;
  32. use function sprintf;
  34. /**
  35.  * Base class for all hydrators. A hydrator is a class that provides some form
  36.  * of transformation of an SQL result set into another structure.
  37.  */
  38. abstract class AbstractHydrator
  39. {
  40.     /**
  41.      * The ResultSetMapping.
  42.      *
  43.      * @var ResultSetMapping|null
  44.      */
  45.     protected $_rsm;
  47.     /**
  48.      * The EntityManager instance.
  49.      *
  50.      * @var EntityManagerInterface
  51.      */
  52.     protected $_em;
  54.     /**
  55.      * The dbms Platform instance.
  56.      *
  57.      * @var AbstractPlatform
  58.      */
  59.     protected $_platform;
  61.     /**
  62.      * The UnitOfWork of the associated EntityManager.
  63.      *
  64.      * @var UnitOfWork
  65.      */
  66.     protected $_uow;
  68.     /**
  69.      * Local ClassMetadata cache to avoid going to the EntityManager all the time.
  70.      *
  71.      * @var array<string, ClassMetadata<object>>
  72.      */
  73.     protected $_metadataCache = [];
  75.     /**
  76.      * The cache used during row-by-row hydration.
  77.      *
  78.      * @var array<string, mixed[]|null>
  79.      */
  80.     protected $_cache = [];
  82.     /**
  83.      * The statement that provides the data to hydrate.
  84.      *
  85.      * @var Result|null
  86.      */
  87.     protected $_stmt;
  89.     /**
  90.      * The query hints.
  91.      *
  92.      * @var array<string, mixed>
  93.      */
  94.     protected $_hints = [];
  96.     /**
  97.      * Initializes a new instance of a class derived from <tt>AbstractHydrator</tt>.
  98.      *
  99.      * @param EntityManagerInterface $em The EntityManager to use.
  100.      */
  101.     public function __construct(EntityManagerInterface $em)
  102.     {
  103.         $this->_em       = $em;
  104.         $this->_platform = $em->getConnection()->getDatabasePlatform();
  105.         $this->_uow      = $em->getUnitOfWork();
  106.     }
  108.     /**
  109.      * Initiates a row-by-row hydration.
  110.      *
  111.      * @deprecated
  112.      *
  113.      * @param Result|ResultStatement $stmt
  114.      * @param ResultSetMapping       $resultSetMapping
  115.      * @psalm-param array<string, mixed> $hints
  116.      *
  117.      * @return IterableResult
  118.      */
  119.     public function iterate($stmt, $resultSetMapping, array $hints = [])
  120.     {
  121.         Deprecation::trigger(
  122.             'doctrine/orm',
  123.             'https://github.com/doctrine/orm/issues/8463',
  124.             'Method %s() is deprecated and will be removed in Doctrine ORM 3.0. Use toIterable() instead.',
  125.             __METHOD__
  126.         );
  128.         $this->_stmt  = $stmt instanceof ResultStatement ? ForwardCompatibilityResult::ensure($stmt) : $stmt;
  129.         $this->_rsm   = $resultSetMapping;
  130.         $this->_hints = $hints;
  132.         $evm = $this->_em->getEventManager();
  134.         $evm->addEventListener([Events::onClear], $this);
  136.         $this->prepare();
  138.         return new IterableResult($this);
  139.     }
  141.     /**
  142.      * Initiates a row-by-row hydration.
  143.      *
  144.      * @param Result|ResultStatement $stmt
  145.      * @psalm-param array<string, mixed> $hints
  146.      *
  147.      * @return Generator<array-key, mixed>
  148.      *
  149.      * @final
  150.      */
  151.     public function toIterable($stmt, ResultSetMapping $resultSetMapping, array $hints = []): iterable
  152.     {
  153.         if (! $stmt instanceof Result) {
  154.             if (! $stmt instanceof ResultStatement) {
  155.                 throw new TypeError(sprintf(
  156.                     '%s: Expected parameter $stmt to be an instance of %s or %s, got %s',
  157.                     __METHOD__,
  158.                     Result::class,
  159.                     ResultStatement::class,
  160.                     get_debug_type($stmt)
  161.                 ));
  162.             }
  164.             Deprecation::trigger(
  165.                 'doctrine/orm',
  166.                 'https://github.com/doctrine/orm/pull/8796',
  167.                 '%s: Passing a result as $stmt that does not implement %s is deprecated and will cause a TypeError on 3.0',
  168.                 __METHOD__,
  169.                 Result::class
  170.             );
  172.             $stmt = ForwardCompatibilityResult::ensure($stmt);
  173.         }
  175.         $this->_stmt  = $stmt;
  176.         $this->_rsm   = $resultSetMapping;
  177.         $this->_hints = $hints;
  179.         $evm = $this->_em->getEventManager();
  181.         $evm->addEventListener([Events::onClear], $this);
  183.         $this->prepare();
  185.         try {
  186.             while (true) {
  187.                 $row = $this->statement()->fetchAssociative();
  189.                 if ($row === false) {
  190.                     break;
  191.                 }
  193.                 $result = [];
  195.                 $this->hydrateRowData($row, $result);
  197.                 $this->cleanupAfterRowIteration();
  198.                 if (count($result) === 1) {
  199.                     if (count($resultSetMapping->indexByMap) === 0) {
  200.                         yield end($result);
  201.                     } else {
  202.                         yield from $result;
  203.                     }
  204.                 } else {
  205.                     yield $result;
  206.                 }
  207.             }
  208.         } finally {
  209.             $this->cleanup();
  210.         }
  211.     }
  213.     final protected function statement(): Result
  214.     {
  215.         if ($this->_stmt === null) {
  216.             throw new LogicException('Uninitialized _stmt property');
  217.         }
  219.         return $this->_stmt;
  220.     }
  222.     final protected function resultSetMapping(): ResultSetMapping
  223.     {
  224.         if ($this->_rsm === null) {
  225.             throw new LogicException('Uninitialized _rsm property');
  226.         }
  228.         return $this->_rsm;
  229.     }
  231.     /**
  232.      * Hydrates all rows returned by the passed statement instance at once.
  233.      *
  234.      * @param Result|ResultStatement $stmt
  235.      * @param ResultSetMapping       $resultSetMapping
  236.      * @psalm-param array<string, string> $hints
  237.      *
  238.      * @return mixed[]
  239.      */
  240.     public function hydrateAll($stmt, $resultSetMapping, array $hints = [])
  241.     {
  242.         if (! $stmt instanceof Result) {
  243.             if (! $stmt instanceof ResultStatement) {
  244.                 throw new TypeError(sprintf(
  245.                     '%s: Expected parameter $stmt to be an instance of %s or %s, got %s',
  246.                     __METHOD__,
  247.                     Result::class,
  248.                     ResultStatement::class,
  249.                     get_debug_type($stmt)
  250.                 ));
  251.             }
  253.             Deprecation::trigger(
  254.                 'doctrine/orm',
  255.                 'https://github.com/doctrine/orm/pull/8796',
  256.                 '%s: Passing a result as $stmt that does not implement %s is deprecated and will cause a TypeError on 3.0',
  257.                 __METHOD__,
  258.                 Result::class
  259.             );
  261.             $stmt = ForwardCompatibilityResult::ensure($stmt);
  262.         }
  264.         $this->_stmt  = $stmt;
  265.         $this->_rsm   = $resultSetMapping;
  266.         $this->_hints = $hints;
  268.         $this->_em->getEventManager()->addEventListener([Events::onClear], $this);
  269.         $this->prepare();
  271.         try {
  272.             $result = $this->hydrateAllData();
  273.         } finally {
  274.             $this->cleanup();
  275.         }
  277.         return $result;
  278.     }
  280.     /**
  281.      * Hydrates a single row returned by the current statement instance during
  282.      * row-by-row hydration with {@link iterate()} or {@link toIterable()}.
  283.      *
  284.      * @deprecated
  285.      *
  286.      * @return mixed[]|false
  287.      */
  288.     public function hydrateRow()
  289.     {
  290.         Deprecation::triggerIfCalledFromOutside(
  291.             'doctrine/orm',
  292.             'https://github.com/doctrine/orm/pull/9072',
  293.             '%s is deprecated.',
  294.             __METHOD__
  295.         );
  297.         $row = $this->statement()->fetchAssociative();
  299.         if ($row === false) {
  300.             $this->cleanup();
  302.             return false;
  303.         }
  305.         $result = [];
  307.         $this->hydrateRowData($row, $result);
  309.         return $result;
  310.     }
  312.     /**
  313.      * When executed in a hydrate() loop we have to clear internal state to
  314.      * decrease memory consumption.
  315.      *
  316.      * @param mixed $eventArgs
  317.      *
  318.      * @return void
  319.      */
  320.     public function onClear($eventArgs)
  321.     {
  322.     }
  324.     /**
  325.      * Executes one-time preparation tasks, once each time hydration is started
  326.      * through {@link hydrateAll} or {@link iterate()}.
  327.      *
  328.      * @return void
  329.      */
  330.     protected function prepare()
  331.     {
  332.     }
  334.     /**
  335.      * Executes one-time cleanup tasks at the end of a hydration that was initiated
  336.      * through {@link hydrateAll} or {@link iterate()}.
  337.      *
  338.      * @return void
  339.      */
  340.     protected function cleanup()
  341.     {
  342.         $this->statement()->free();
  344.         $this->_stmt          = null;
  345.         $this->_rsm           = null;
  346.         $this->_cache         = [];
  347.         $this->_metadataCache = [];
  349.         $this
  350.             ->_em
  351.             ->getEventManager()
  352.             ->removeEventListener([Events::onClear], $this);
  353.     }
  355.     protected function cleanupAfterRowIteration(): void
  356.     {
  357.     }
  359.     /**
  360.      * Hydrates a single row from the current statement instance.
  361.      *
  362.      * Template method.
  363.      *
  364.      * @param mixed[] $row    The row data.
  365.      * @param mixed[] $result The result to fill.
  366.      *
  367.      * @return void
  368.      *
  369.      * @throws HydrationException
  370.      */
  371.     protected function hydrateRowData(array $row, array &$result)
  372.     {
  373.         throw new HydrationException('hydrateRowData() not implemented by this hydrator.');
  374.     }
  376.     /**
  377.      * Hydrates all rows from the current statement instance at once.
  378.      *
  379.      * @return mixed[]
  380.      */
  381.     abstract protected function hydrateAllData();
  383.     /**
  384.      * Processes a row of the result set.
  385.      *
  386.      * Used for identity-based hydration (HYDRATE_OBJECT and HYDRATE_ARRAY).
  387.      * Puts the elements of a result row into a new array, grouped by the dql alias
  388.      * they belong to. The column names in the result set are mapped to their
  389.      * field names during this procedure as well as any necessary conversions on
  390.      * the values applied. Scalar values are kept in a specific key 'scalars'.
  391.      *
  392.      * @param mixed[] $data SQL Result Row.
  393.      * @psalm-param array<string, string> $id                 Dql-Alias => ID-Hash.
  394.      * @psalm-param array<string, bool>   $nonemptyComponents Does this DQL-Alias has at least one non NULL value?
  395.      *
  396.      * @return array<string, array<string, mixed>> An array with all the fields
  397.      *                                             (name => value) of the data
  398.      *                                             row, grouped by their
  399.      *                                             component alias.
  400.      * @psalm-return array{
  401.      *                   data: array<array-key, array>,
  402.      *                   newObjects?: array<array-key, array{
  403.      *                       class: mixed,
  404.      *                       args?: array
  405.      *                   }>,
  406.      *                   scalars?: array
  407.      *               }
  408.      */
  409.     protected function gatherRowData(array $data, array &$id, array &$nonemptyComponents)
  410.     {
  411.         $rowData = ['data' => []];
  413.         foreach ($data as $key => $value) {
  414.             $cacheKeyInfo = $this->hydrateColumnInfo($key);
  415.             if ($cacheKeyInfo === null) {
  416.                 continue;
  417.             }
  419.             $fieldName = $cacheKeyInfo['fieldName'];
  421.             switch (true) {
  422.                 case isset($cacheKeyInfo['isNewObjectParameter']):
  423.                     $argIndex = $cacheKeyInfo['argIndex'];
  424.                     $objIndex = $cacheKeyInfo['objIndex'];
  425.                     $type     = $cacheKeyInfo['type'];
  426.                     $value    = $type->convertToPHPValue($value, $this->_platform);
  428.                     if ($value !== null && isset($cacheKeyInfo['enumType'])) {
  429.                         $value = $this->buildEnum($value, $cacheKeyInfo['enumType']);
  430.                     }
  432.                     $rowData['newObjects'][$objIndex]['class']           = $cacheKeyInfo['class'];
  433.                     $rowData['newObjects'][$objIndex]['args'][$argIndex] = $value;
  434.                     break;
  436.                 case isset($cacheKeyInfo['isScalar']):
  437.                     $type  = $cacheKeyInfo['type'];
  438.                     $value = $type->convertToPHPValue($value, $this->_platform);
  440.                     if ($value !== null && isset($cacheKeyInfo['enumType'])) {
  441.                         $value = $this->buildEnum($value, $cacheKeyInfo['enumType']);
  442.                     }
  444.                     $rowData['scalars'][$fieldName] = $value;
  446.                     break;
  448.                 //case (isset($cacheKeyInfo['isMetaColumn'])):
  449.                 default:
  450.                     $dqlAlias = $cacheKeyInfo['dqlAlias'];
  451.                     $type     = $cacheKeyInfo['type'];
  453.                     // If there are field name collisions in the child class, then we need
  454.                     // to only hydrate if we are looking at the correct discriminator value
  455.                     if (
  456.                         isset($cacheKeyInfo['discriminatorColumn'], $data[$cacheKeyInfo['discriminatorColumn']])
  457.                         && ! in_array((string) $data[$cacheKeyInfo['discriminatorColumn']], $cacheKeyInfo['discriminatorValues'], true)
  458.                     ) {
  459.                         break;
  460.                     }
  462.                     // in an inheritance hierarchy the same field could be defined several times.
  463.                     // We overwrite this value so long we don't have a non-null value, that value we keep.
  464.                     // Per definition it cannot be that a field is defined several times and has several values.
  465.                     if (isset($rowData['data'][$dqlAlias][$fieldName])) {
  466.                         break;
  467.                     }
  469.                     $rowData['data'][$dqlAlias][$fieldName] = $type
  470.                         ? $type->convertToPHPValue($value, $this->_platform)
  471.                         : $value;
  473.                     if ($rowData['data'][$dqlAlias][$fieldName] !== null && isset($cacheKeyInfo['enumType'])) {
  474.                         $rowData['data'][$dqlAlias][$fieldName] = $this->buildEnum($rowData['data'][$dqlAlias][$fieldName], $cacheKeyInfo['enumType']);
  475.                     }
  477.                     if ($cacheKeyInfo['isIdentifier'] && $value !== null) {
  478.                         $id[$dqlAlias]                .= '|' . $value;
  479.                         $nonemptyComponents[$dqlAlias] = true;
  480.                     }
  482.                     break;
  483.             }
  484.         }
  486.         return $rowData;
  487.     }
  489.     /**
  490.      * Processes a row of the result set.
  491.      *
  492.      * Used for HYDRATE_SCALAR. This is a variant of _gatherRowData() that
  493.      * simply converts column names to field names and properly converts the
  494.      * values according to their types. The resulting row has the same number
  495.      * of elements as before.
  496.      *
  497.      * @param mixed[] $data
  498.      * @psalm-param array<string, mixed> $data
  499.      *
  500.      * @return mixed[] The processed row.
  501.      * @psalm-return array<string, mixed>
  502.      */
  503.     protected function gatherScalarRowData(&$data)
  504.     {
  505.         $rowData = [];
  507.         foreach ($data as $key => $value) {
  508.             $cacheKeyInfo = $this->hydrateColumnInfo($key);
  509.             if ($cacheKeyInfo === null) {
  510.                 continue;
  511.             }
  513.             $fieldName = $cacheKeyInfo['fieldName'];
  515.             // WARNING: BC break! We know this is the desired behavior to type convert values, but this
  516.             // erroneous behavior exists since 2.0 and we're forced to keep compatibility.
  517.             if (! isset($cacheKeyInfo['isScalar'])) {
  518.                 $type  = $cacheKeyInfo['type'];
  519.                 $value = $type ? $type->convertToPHPValue($value, $this->_platform) : $value;
  521.                 $fieldName = $cacheKeyInfo['dqlAlias'] . '_' . $fieldName;
  522.             }
  524.             $rowData[$fieldName] = $value;
  525.         }
  527.         return $rowData;
  528.     }
  530.     /**
  531.      * Retrieve column information from ResultSetMapping.
  532.      *
  533.      * @param string $key Column name
  534.      *
  535.      * @return mixed[]|null
  536.      * @psalm-return array<string, mixed>|null
  537.      */
  538.     protected function hydrateColumnInfo($key)
  539.     {
  540.         if (isset($this->_cache[$key])) {
  541.             return $this->_cache[$key];
  542.         }
  544.         switch (true) {
  545.             // NOTE: Most of the times it's a field mapping, so keep it first!!!
  546.             case isset($this->_rsm->fieldMappings[$key]):
  547.                 $classMetadata = $this->getClassMetadata($this->_rsm->declaringClasses[$key]);
  548.                 $fieldName     = $this->_rsm->fieldMappings[$key];
  549.                 $fieldMapping  = $classMetadata->fieldMappings[$fieldName];
  550.                 $ownerMap      = $this->_rsm->columnOwnerMap[$key];
  551.                 $columnInfo    = [
  552.                     'isIdentifier' => in_array($fieldName, $classMetadata->identifier, true),
  553.                     'fieldName'    => $fieldName,
  554.                     'type'         => Type::getType($fieldMapping['type']),
  555.                     'dqlAlias'     => $ownerMap,
  556.                     'enumType'     => $this->_rsm->enumMappings[$key] ?? null,
  557.                 ];
  559.                 // the current discriminator value must be saved in order to disambiguate fields hydration,
  560.                 // should there be field name collisions
  561.                 if ($classMetadata->parentClasses && isset($this->_rsm->discriminatorColumns[$ownerMap])) {
  562.                     return $this->_cache[$key] = array_merge(
  563.                         $columnInfo,
  564.                         [
  565.                             'discriminatorColumn' => $this->_rsm->discriminatorColumns[$ownerMap],
  566.                             'discriminatorValue'  => $classMetadata->discriminatorValue,
  567.                             'discriminatorValues' => $this->getDiscriminatorValues($classMetadata),
  568.                         ]
  569.                     );
  570.                 }
  572.                 return $this->_cache[$key] = $columnInfo;
  574.             case isset($this->_rsm->newObjectMappings[$key]):
  575.                 // WARNING: A NEW object is also a scalar, so it must be declared before!
  576.                 $mapping = $this->_rsm->newObjectMappings[$key];
  578.                 return $this->_cache[$key] = [
  579.                     'isScalar'             => true,
  580.                     'isNewObjectParameter' => true,
  581.                     'fieldName'            => $this->_rsm->scalarMappings[$key],
  582.                     'type'                 => Type::getType($this->_rsm->typeMappings[$key]),
  583.                     'argIndex'             => $mapping['argIndex'],
  584.                     'objIndex'             => $mapping['objIndex'],
  585.                     'class'                => new ReflectionClass($mapping['className']),
  586.                     'enumType'             => $this->_rsm->enumMappings[$key] ?? null,
  587.                 ];
  589.             case isset($this->_rsm->scalarMappings[$key], $this->_hints[LimitSubqueryWalker::FORCE_DBAL_TYPE_CONVERSION]):
  590.                 return $this->_cache[$key] = [
  591.                     'fieldName' => $this->_rsm->scalarMappings[$key],
  592.                     'type'      => Type::getType($this->_rsm->typeMappings[$key]),
  593.                     'dqlAlias'  => '',
  594.                     'enumType'  => $this->_rsm->enumMappings[$key] ?? null,
  595.                 ];
  597.             case isset($this->_rsm->scalarMappings[$key]):
  598.                 return $this->_cache[$key] = [
  599.                     'isScalar'  => true,
  600.                     'fieldName' => $this->_rsm->scalarMappings[$key],
  601.                     'type'      => Type::getType($this->_rsm->typeMappings[$key]),
  602.                     'enumType'  => $this->_rsm->enumMappings[$key] ?? null,
  603.                 ];
  605.             case isset($this->_rsm->metaMappings[$key]):
  606.                 // Meta column (has meaning in relational schema only, i.e. foreign keys or discriminator columns).
  607.                 $fieldName = $this->_rsm->metaMappings[$key];
  608.                 $dqlAlias  = $this->_rsm->columnOwnerMap[$key];
  609.                 $type      = isset($this->_rsm->typeMappings[$key])
  610.                     ? Type::getType($this->_rsm->typeMappings[$key])
  611.                     : null;
  613.                 // Cache metadata fetch
  614.                 $this->getClassMetadata($this->_rsm->aliasMap[$dqlAlias]);
  616.                 return $this->_cache[$key] = [
  617.                     'isIdentifier' => isset($this->_rsm->isIdentifierColumn[$dqlAlias][$key]),
  618.                     'isMetaColumn' => true,
  619.                     'fieldName'    => $fieldName,
  620.                     'type'         => $type,
  621.                     'dqlAlias'     => $dqlAlias,
  622.                     'enumType'     => $this->_rsm->enumMappings[$key] ?? null,
  623.                 ];
  624.         }
  626.         // this column is a left over, maybe from a LIMIT query hack for example in Oracle or DB2
  627.         // maybe from an additional column that has not been defined in a NativeQuery ResultSetMapping.
  628.         return null;
  629.     }
  631.     /**
  632.      * @return string[]
  633.      * @psalm-return non-empty-list<string>
  634.      */
  635.     private function getDiscriminatorValues(ClassMetadata $classMetadata): array
  636.     {
  637.         $values = array_map(
  638.             function (string $subClass): string {
  639.                 return (string) $this->getClassMetadata($subClass)->discriminatorValue;
  640.             },
  641.             $classMetadata->subClasses
  642.         );
  644.         $values[] = (string) $classMetadata->discriminatorValue;
  646.         return $values;
  647.     }
  649.     /**
  650.      * Retrieve ClassMetadata associated to entity class name.
  651.      *
  652.      * @param string $className
  653.      *
  654.      * @return ClassMetadata
  655.      */
  656.     protected function getClassMetadata($className)
  657.     {
  658.         if (! isset($this->_metadataCache[$className])) {
  659.             $this->_metadataCache[$className] = $this->_em->getClassMetadata($className);
  660.         }
  662.         return $this->_metadataCache[$className];
  663.     }
  665.     /**
  666.      * Register entity as managed in UnitOfWork.
  667.      *
  668.      * @param object  $entity
  669.      * @param mixed[] $data
  670.      *
  671.      * @return void
  672.      *
  673.      * @todo The "$id" generation is the same of UnitOfWork#createEntity. Remove this duplication somehow
  674.      */
  675.     protected function registerManaged(ClassMetadata $class, $entity, array $data)
  676.     {
  677.         if ($class->isIdentifierComposite) {
  678.             $id = [];
  680.             foreach ($class->identifier as $fieldName) {
  681.                 $id[$fieldName] = isset($class->associationMappings[$fieldName])
  682.                     ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']]
  683.                     : $data[$fieldName];
  684.             }
  685.         } else {
  686.             $fieldName = $class->identifier[0];
  687.             $id        = [
  688.                 $fieldName => isset($class->associationMappings[$fieldName])
  689.                     ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']]
  690.                     : $data[$fieldName],
  691.             ];
  692.         }
  694.         $this->_em->getUnitOfWork()->registerManaged($entity, $id, $data);
  695.     }
  697.     /**
  698.      * @param mixed                    $value
  699.      * @param class-string<BackedEnum> $enumType
  700.      *
  701.      * @return BackedEnum|array<BackedEnum>
  702.      */
  703.     final protected function buildEnum($value, string $enumType)
  704.     {
  705.         if (is_array($value)) {
  706.             return array_map(static function ($value) use ($enumType): BackedEnum {
  707.                 return $enumType::from($value);
  708.             }, $value);
  709.         }
  711.         return $enumType::from($value);
  712.     }
  713. }