vendor/doctrine/orm/lib/Doctrine/ORM/Internal/Hydration/AbstractHydrator.php line 270

  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.         while (true) {
  186.             $row = $this->statement()->fetchAssociative();
  188.             if ($row === false) {
  189.                 $this->cleanup();
  191.                 break;
  192.             }
  194.             $result = [];
  196.             $this->hydrateRowData($row, $result);
  198.             $this->cleanupAfterRowIteration();
  199.             if (count($result) === 1) {
  200.                 if (count($resultSetMapping->indexByMap) === 0) {
  201.                     yield end($result);
  202.                 } else {
  203.                     yield from $result;
  204.                 }
  205.             } else {
  206.                 yield $result;
  207.             }
  208.         }
  209.     }
  211.     final protected function statement(): Result
  212.     {
  213.         if ($this->_stmt === null) {
  214.             throw new LogicException('Uninitialized _stmt property');
  215.         }
  217.         return $this->_stmt;
  218.     }
  220.     final protected function resultSetMapping(): ResultSetMapping
  221.     {
  222.         if ($this->_rsm === null) {
  223.             throw new LogicException('Uninitialized _rsm property');
  224.         }
  226.         return $this->_rsm;
  227.     }
  229.     /**
  230.      * Hydrates all rows returned by the passed statement instance at once.
  231.      *
  232.      * @param Result|ResultStatement $stmt
  233.      * @param ResultSetMapping       $resultSetMapping
  234.      * @psalm-param array<string, string> $hints
  235.      *
  236.      * @return mixed[]
  237.      */
  238.     public function hydrateAll($stmt, $resultSetMapping, array $hints = [])
  239.     {
  240.         if (! $stmt instanceof Result) {
  241.             if (! $stmt instanceof ResultStatement) {
  242.                 throw new TypeError(sprintf(
  243.                     '%s: Expected parameter $stmt to be an instance of %s or %s, got %s',
  244.                     __METHOD__,
  245.                     Result::class,
  246.                     ResultStatement::class,
  247.                     get_debug_type($stmt)
  248.                 ));
  249.             }
  251.             Deprecation::trigger(
  252.                 'doctrine/orm',
  253.                 'https://github.com/doctrine/orm/pull/8796',
  254.                 '%s: Passing a result as $stmt that does not implement %s is deprecated and will cause a TypeError on 3.0',
  255.                 __METHOD__,
  256.                 Result::class
  257.             );
  259.             $stmt = ForwardCompatibilityResult::ensure($stmt);
  260.         }
  262.         $this->_stmt  = $stmt;
  263.         $this->_rsm   = $resultSetMapping;
  264.         $this->_hints = $hints;
  266.         $this->_em->getEventManager()->addEventListener([Events::onClear], $this);
  267.         $this->prepare();
  269.         try {
  270.             $result = $this->hydrateAllData();
  271.         } finally {
  272.             $this->cleanup();
  273.         }
  275.         return $result;
  276.     }
  278.     /**
  279.      * Hydrates a single row returned by the current statement instance during
  280.      * row-by-row hydration with {@link iterate()} or {@link toIterable()}.
  281.      *
  282.      * @deprecated
  283.      *
  284.      * @return mixed[]|false
  285.      */
  286.     public function hydrateRow()
  287.     {
  288.         Deprecation::triggerIfCalledFromOutside(
  289.             'doctrine/orm',
  290.             'https://github.com/doctrine/orm/pull/9072',
  291.             '%s is deprecated.',
  292.             __METHOD__
  293.         );
  295.         $row = $this->statement()->fetchAssociative();
  297.         if ($row === false) {
  298.             $this->cleanup();
  300.             return false;
  301.         }
  303.         $result = [];
  305.         $this->hydrateRowData($row, $result);
  307.         return $result;
  308.     }
  310.     /**
  311.      * When executed in a hydrate() loop we have to clear internal state to
  312.      * decrease memory consumption.
  313.      *
  314.      * @param mixed $eventArgs
  315.      *
  316.      * @return void
  317.      */
  318.     public function onClear($eventArgs)
  319.     {
  320.     }
  322.     /**
  323.      * Executes one-time preparation tasks, once each time hydration is started
  324.      * through {@link hydrateAll} or {@link iterate()}.
  325.      *
  326.      * @return void
  327.      */
  328.     protected function prepare()
  329.     {
  330.     }
  332.     /**
  333.      * Executes one-time cleanup tasks at the end of a hydration that was initiated
  334.      * through {@link hydrateAll} or {@link iterate()}.
  335.      *
  336.      * @return void
  337.      */
  338.     protected function cleanup()
  339.     {
  340.         $this->statement()->free();
  342.         $this->_stmt          = null;
  343.         $this->_rsm           = null;
  344.         $this->_cache         = [];
  345.         $this->_metadataCache = [];
  347.         $this
  348.             ->_em
  349.             ->getEventManager()
  350.             ->removeEventListener([Events::onClear], $this);
  351.     }
  353.     protected function cleanupAfterRowIteration(): void
  354.     {
  355.     }
  357.     /**
  358.      * Hydrates a single row from the current statement instance.
  359.      *
  360.      * Template method.
  361.      *
  362.      * @param mixed[] $row    The row data.
  363.      * @param mixed[] $result The result to fill.
  364.      *
  365.      * @return void
  366.      *
  367.      * @throws HydrationException
  368.      */
  369.     protected function hydrateRowData(array $row, array &$result)
  370.     {
  371.         throw new HydrationException('hydrateRowData() not implemented by this hydrator.');
  372.     }
  374.     /**
  375.      * Hydrates all rows from the current statement instance at once.
  376.      *
  377.      * @return mixed[]
  378.      */
  379.     abstract protected function hydrateAllData();
  381.     /**
  382.      * Processes a row of the result set.
  383.      *
  384.      * Used for identity-based hydration (HYDRATE_OBJECT and HYDRATE_ARRAY).
  385.      * Puts the elements of a result row into a new array, grouped by the dql alias
  386.      * they belong to. The column names in the result set are mapped to their
  387.      * field names during this procedure as well as any necessary conversions on
  388.      * the values applied. Scalar values are kept in a specific key 'scalars'.
  389.      *
  390.      * @param mixed[] $data SQL Result Row.
  391.      * @psalm-param array<string, string> $id                 Dql-Alias => ID-Hash.
  392.      * @psalm-param array<string, bool>   $nonemptyComponents Does this DQL-Alias has at least one non NULL value?
  393.      *
  394.      * @return array<string, array<string, mixed>> An array with all the fields
  395.      *                                             (name => value) of the data
  396.      *                                             row, grouped by their
  397.      *                                             component alias.
  398.      * @psalm-return array{
  399.      *                   data: array<array-key, array>,
  400.      *                   newObjects?: array<array-key, array{
  401.      *                       class: mixed,
  402.      *                       args?: array
  403.      *                   }>,
  404.      *                   scalars?: array
  405.      *               }
  406.      */
  407.     protected function gatherRowData(array $data, array &$id, array &$nonemptyComponents)
  408.     {
  409.         $rowData = ['data' => []];
  411.         foreach ($data as $key => $value) {
  412.             $cacheKeyInfo = $this->hydrateColumnInfo($key);
  413.             if ($cacheKeyInfo === null) {
  414.                 continue;
  415.             }
  417.             $fieldName = $cacheKeyInfo['fieldName'];
  419.             switch (true) {
  420.                 case isset($cacheKeyInfo['isNewObjectParameter']):
  421.                     $argIndex = $cacheKeyInfo['argIndex'];
  422.                     $objIndex = $cacheKeyInfo['objIndex'];
  423.                     $type     = $cacheKeyInfo['type'];
  424.                     $value    = $type->convertToPHPValue($value, $this->_platform);
  426.                     if ($value !== null && isset($cacheKeyInfo['enumType'])) {
  427.                         $value = $this->buildEnum($value, $cacheKeyInfo['enumType']);
  428.                     }
  430.                     $rowData['newObjects'][$objIndex]['class']           = $cacheKeyInfo['class'];
  431.                     $rowData['newObjects'][$objIndex]['args'][$argIndex] = $value;
  432.                     break;
  434.                 case isset($cacheKeyInfo['isScalar']):
  435.                     $type  = $cacheKeyInfo['type'];
  436.                     $value = $type->convertToPHPValue($value, $this->_platform);
  438.                     if ($value !== null && isset($cacheKeyInfo['enumType'])) {
  439.                         $value = $this->buildEnum($value, $cacheKeyInfo['enumType']);
  440.                     }
  442.                     $rowData['scalars'][$fieldName] = $value;
  444.                     break;
  446.                 //case (isset($cacheKeyInfo['isMetaColumn'])):
  447.                 default:
  448.                     $dqlAlias = $cacheKeyInfo['dqlAlias'];
  449.                     $type     = $cacheKeyInfo['type'];
  451.                     // If there are field name collisions in the child class, then we need
  452.                     // to only hydrate if we are looking at the correct discriminator value
  453.                     if (
  454.                         isset($cacheKeyInfo['discriminatorColumn'], $data[$cacheKeyInfo['discriminatorColumn']])
  455.                         && ! in_array((string) $data[$cacheKeyInfo['discriminatorColumn']], $cacheKeyInfo['discriminatorValues'], true)
  456.                     ) {
  457.                         break;
  458.                     }
  460.                     // in an inheritance hierarchy the same field could be defined several times.
  461.                     // We overwrite this value so long we don't have a non-null value, that value we keep.
  462.                     // Per definition it cannot be that a field is defined several times and has several values.
  463.                     if (isset($rowData['data'][$dqlAlias][$fieldName])) {
  464.                         break;
  465.                     }
  467.                     $rowData['data'][$dqlAlias][$fieldName] = $type
  468.                         ? $type->convertToPHPValue($value, $this->_platform)
  469.                         : $value;
  471.                     if ($rowData['data'][$dqlAlias][$fieldName] !== null && isset($cacheKeyInfo['enumType'])) {
  472.                         $rowData['data'][$dqlAlias][$fieldName] = $this->buildEnum($rowData['data'][$dqlAlias][$fieldName], $cacheKeyInfo['enumType']);
  473.                     }
  475.                     if ($cacheKeyInfo['isIdentifier'] && $value !== null) {
  476.                         $id[$dqlAlias]                .= '|' . $value;
  477.                         $nonemptyComponents[$dqlAlias] = true;
  478.                     }
  480.                     break;
  481.             }
  482.         }
  484.         return $rowData;
  485.     }
  487.     /**
  488.      * Processes a row of the result set.
  489.      *
  490.      * Used for HYDRATE_SCALAR. This is a variant of _gatherRowData() that
  491.      * simply converts column names to field names and properly converts the
  492.      * values according to their types. The resulting row has the same number
  493.      * of elements as before.
  494.      *
  495.      * @param mixed[] $data
  496.      * @psalm-param array<string, mixed> $data
  497.      *
  498.      * @return mixed[] The processed row.
  499.      * @psalm-return array<string, mixed>
  500.      */
  501.     protected function gatherScalarRowData(&$data)
  502.     {
  503.         $rowData = [];
  505.         foreach ($data as $key => $value) {
  506.             $cacheKeyInfo = $this->hydrateColumnInfo($key);
  507.             if ($cacheKeyInfo === null) {
  508.                 continue;
  509.             }
  511.             $fieldName = $cacheKeyInfo['fieldName'];
  513.             // WARNING: BC break! We know this is the desired behavior to type convert values, but this
  514.             // erroneous behavior exists since 2.0 and we're forced to keep compatibility.
  515.             if (! isset($cacheKeyInfo['isScalar'])) {
  516.                 $type  = $cacheKeyInfo['type'];
  517.                 $value = $type ? $type->convertToPHPValue($value, $this->_platform) : $value;
  519.                 $fieldName = $cacheKeyInfo['dqlAlias'] . '_' . $fieldName;
  520.             }
  522.             $rowData[$fieldName] = $value;
  523.         }
  525.         return $rowData;
  526.     }
  528.     /**
  529.      * Retrieve column information from ResultSetMapping.
  530.      *
  531.      * @param string $key Column name
  532.      *
  533.      * @return mixed[]|null
  534.      * @psalm-return array<string, mixed>|null
  535.      */
  536.     protected function hydrateColumnInfo($key)
  537.     {
  538.         if (isset($this->_cache[$key])) {
  539.             return $this->_cache[$key];
  540.         }
  542.         switch (true) {
  543.             // NOTE: Most of the times it's a field mapping, so keep it first!!!
  544.             case isset($this->_rsm->fieldMappings[$key]):
  545.                 $classMetadata = $this->getClassMetadata($this->_rsm->declaringClasses[$key]);
  546.                 $fieldName     = $this->_rsm->fieldMappings[$key];
  547.                 $fieldMapping  = $classMetadata->fieldMappings[$fieldName];
  548.                 $ownerMap      = $this->_rsm->columnOwnerMap[$key];
  549.                 $columnInfo    = [
  550.                     'isIdentifier' => in_array($fieldName, $classMetadata->identifier, true),
  551.                     'fieldName'    => $fieldName,
  552.                     'type'         => Type::getType($fieldMapping['type']),
  553.                     'dqlAlias'     => $ownerMap,
  554.                     'enumType'     => $this->_rsm->enumMappings[$key] ?? null,
  555.                 ];
  557.                 // the current discriminator value must be saved in order to disambiguate fields hydration,
  558.                 // should there be field name collisions
  559.                 if ($classMetadata->parentClasses && isset($this->_rsm->discriminatorColumns[$ownerMap])) {
  560.                     return $this->_cache[$key] = array_merge(
  561.                         $columnInfo,
  562.                         [
  563.                             'discriminatorColumn' => $this->_rsm->discriminatorColumns[$ownerMap],
  564.                             'discriminatorValue'  => $classMetadata->discriminatorValue,
  565.                             'discriminatorValues' => $this->getDiscriminatorValues($classMetadata),
  566.                         ]
  567.                     );
  568.                 }
  570.                 return $this->_cache[$key] = $columnInfo;
  572.             case isset($this->_rsm->newObjectMappings[$key]):
  573.                 // WARNING: A NEW object is also a scalar, so it must be declared before!
  574.                 $mapping = $this->_rsm->newObjectMappings[$key];
  576.                 return $this->_cache[$key] = [
  577.                     'isScalar'             => true,
  578.                     'isNewObjectParameter' => true,
  579.                     'fieldName'            => $this->_rsm->scalarMappings[$key],
  580.                     'type'                 => Type::getType($this->_rsm->typeMappings[$key]),
  581.                     'argIndex'             => $mapping['argIndex'],
  582.                     'objIndex'             => $mapping['objIndex'],
  583.                     'class'                => new ReflectionClass($mapping['className']),
  584.                     'enumType'             => $this->_rsm->enumMappings[$key] ?? null,
  585.                 ];
  587.             case isset($this->_rsm->scalarMappings[$key], $this->_hints[LimitSubqueryWalker::FORCE_DBAL_TYPE_CONVERSION]):
  588.                 return $this->_cache[$key] = [
  589.                     'fieldName' => $this->_rsm->scalarMappings[$key],
  590.                     'type'      => Type::getType($this->_rsm->typeMappings[$key]),
  591.                     'dqlAlias'  => '',
  592.                     'enumType'  => $this->_rsm->enumMappings[$key] ?? null,
  593.                 ];
  595.             case isset($this->_rsm->scalarMappings[$key]):
  596.                 return $this->_cache[$key] = [
  597.                     'isScalar'  => true,
  598.                     'fieldName' => $this->_rsm->scalarMappings[$key],
  599.                     'type'      => Type::getType($this->_rsm->typeMappings[$key]),
  600.                     'enumType'  => $this->_rsm->enumMappings[$key] ?? null,
  601.                 ];
  603.             case isset($this->_rsm->metaMappings[$key]):
  604.                 // Meta column (has meaning in relational schema only, i.e. foreign keys or discriminator columns).
  605.                 $fieldName = $this->_rsm->metaMappings[$key];
  606.                 $dqlAlias  = $this->_rsm->columnOwnerMap[$key];
  607.                 $type      = isset($this->_rsm->typeMappings[$key])
  608.                     ? Type::getType($this->_rsm->typeMappings[$key])
  609.                     : null;
  611.                 // Cache metadata fetch
  612.                 $this->getClassMetadata($this->_rsm->aliasMap[$dqlAlias]);
  614.                 return $this->_cache[$key] = [
  615.                     'isIdentifier' => isset($this->_rsm->isIdentifierColumn[$dqlAlias][$key]),
  616.                     'isMetaColumn' => true,
  617.                     'fieldName'    => $fieldName,
  618.                     'type'         => $type,
  619.                     'dqlAlias'     => $dqlAlias,
  620.                     'enumType'     => $this->_rsm->enumMappings[$key] ?? null,
  621.                 ];
  622.         }
  624.         // this column is a left over, maybe from a LIMIT query hack for example in Oracle or DB2
  625.         // maybe from an additional column that has not been defined in a NativeQuery ResultSetMapping.
  626.         return null;
  627.     }
  629.     /**
  630.      * @return string[]
  631.      * @psalm-return non-empty-list<string>
  632.      */
  633.     private function getDiscriminatorValues(ClassMetadata $classMetadata): array
  634.     {
  635.         $values = array_map(
  636.             function (string $subClass): string {
  637.                 return (string) $this->getClassMetadata($subClass)->discriminatorValue;
  638.             },
  639.             $classMetadata->subClasses
  640.         );
  642.         $values[] = (string) $classMetadata->discriminatorValue;
  644.         return $values;
  645.     }
  647.     /**
  648.      * Retrieve ClassMetadata associated to entity class name.
  649.      *
  650.      * @param string $className
  651.      *
  652.      * @return ClassMetadata
  653.      */
  654.     protected function getClassMetadata($className)
  655.     {
  656.         if (! isset($this->_metadataCache[$className])) {
  657.             $this->_metadataCache[$className] = $this->_em->getClassMetadata($className);
  658.         }
  660.         return $this->_metadataCache[$className];
  661.     }
  663.     /**
  664.      * Register entity as managed in UnitOfWork.
  665.      *
  666.      * @param object  $entity
  667.      * @param mixed[] $data
  668.      *
  669.      * @return void
  670.      *
  671.      * @todo The "$id" generation is the same of UnitOfWork#createEntity. Remove this duplication somehow
  672.      */
  673.     protected function registerManaged(ClassMetadata $class, $entity, array $data)
  674.     {
  675.         if ($class->isIdentifierComposite) {
  676.             $id = [];
  678.             foreach ($class->identifier as $fieldName) {
  679.                 $id[$fieldName] = isset($class->associationMappings[$fieldName])
  680.                     ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']]
  681.                     : $data[$fieldName];
  682.             }
  683.         } else {
  684.             $fieldName = $class->identifier[0];
  685.             $id        = [
  686.                 $fieldName => isset($class->associationMappings[$fieldName])
  687.                     ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']]
  688.                     : $data[$fieldName],
  689.             ];
  690.         }
  692.         $this->_em->getUnitOfWork()->registerManaged($entity, $id, $data);
  693.     }
  695.     /**
  696.      * @param mixed                    $value
  697.      * @param class-string<BackedEnum> $enumType
  698.      *
  699.      * @return BackedEnum|array<BackedEnum>
  700.      */
  701.     final protected function buildEnum($value, string $enumType)
  702.     {
  703.         if (is_array($value)) {
  704.             return array_map(static function ($value) use ($enumType): BackedEnum {
  705.                 return $enumType::from($value);
  706.             }, $value);
  707.         }
  709.         return $enumType::from($value);
  710.     }
  711. }