src/Core/Framework/DataAbstractionLayer/Dbal/EntityHydrator.php line 267

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer\Dbal;
  5. use Shopware\Core\Framework\Context;
  6. use Shopware\Core\Framework\DataAbstractionLayer\Entity;
  7. use Shopware\Core\Framework\DataAbstractionLayer\EntityCollection;
  8. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Field\AssociationField;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Field\CustomFields;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Field\Field;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Extension;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Inherited;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToManyAssociationField;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToOneAssociationField;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Field\OneToOneAssociationField;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Field\ParentAssociationField;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Field\ReferenceVersionField;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Field\TranslatedField;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Field\VersionField;
  21. use Shopware\Core\Framework\DataAbstractionLayer\PartialEntity;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\WriteCommandQueue;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Write\DataStack\KeyValuePair;
  24. use Shopware\Core\Framework\DataAbstractionLayer\Write\EntityExistence;
  25. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteContext;
  26. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteParameterBag;
  27. use Shopware\Core\Framework\Log\Package;
  28. use Shopware\Core\Framework\Struct\ArrayEntity;
  29. use Shopware\Core\Framework\Struct\ArrayStruct;
  30. use Symfony\Component\DependencyInjection\ContainerInterface;
  32. /**
  33.  * Allows to hydrate database values into struct objects.
  34.  *
  35.  * @internal
  36.  */
  37. #[Package('core')]
  38. class EntityHydrator
  39. {
  40.     /**
  41.      * @var array<mixed>
  42.      */
  43.     protected static array $partial = [];
  45.     /**
  46.      * @var array<mixed>
  47.      */
  48.     private static array $hydrated = [];
  50.     /**
  51.      * @var array<string>
  52.      */
  53.     private static array $manyToOne = [];
  55.     /**
  56.      * @var array<string, array<string, Field>>
  57.      */
  58.     private static array $translatedFields = [];
  60.     /**
  61.      * @internal
  62.      */
  63.     public function __construct(private readonly ContainerInterface $container)
  64.     {
  65.     }
  67.     /**
  68.      * @param EntityCollection<Entity> $collection
  69.      * @param array<mixed> $rows
  70.      * @param array<string|array<string>> $partial
  71.      *
  72.      * @return EntityCollection<Entity>
  73.      */
  74.     public function hydrate(EntityCollection $collection, string $entityClass, EntityDefinition $definition, array $rows, string $root, Context $context, array $partial = []): EntityCollection
  75.     {
  76.         self::$hydrated = [];
  78.         self::$partial = $partial;
  80.         if (!empty(self::$partial)) {
  81.             $collection = new EntityCollection();
  82.         }
  84.         foreach ($rows as $row) {
  85.             $collection->add($this->hydrateEntity($definition, $entityClass, $row, $root, $context, $partial));
  86.         }
  88.         return $collection;
  89.     }
  91.     /**
  92.      * @template EntityClass
  93.      *
  94.      * @param class-string<EntityClass> $class
  95.      *
  96.      * @return EntityClass
  97.      */
  98.     final public static function createClass(string $class)
  99.     {
  100.         return new $class();
  101.     }
  103.     /**
  104.      * @param array<mixed> $row
  105.      *
  106.      * @return array<mixed>
  107.      */
  108.     final public static function buildUniqueIdentifier(EntityDefinition $definition, array $row, string $root): array
  109.     {
  110.         $primaryKeyFields = $definition->getPrimaryKeys();
  111.         $primaryKey = [];
  113.         foreach ($primaryKeyFields as $field) {
  114.             if ($field instanceof VersionField || $field instanceof ReferenceVersionField) {
  115.                 continue;
  116.             }
  117.             $accessor = $root . '.' . $field->getPropertyName();
  119.             $primaryKey[$field->getPropertyName()] = $field->getSerializer()->decode($field, $row[$accessor]);
  120.         }
  122.         return $primaryKey;
  123.     }
  125.     /**
  126.      * @param array<string> $primaryKey
  127.      *
  128.      * @return array<string>
  129.      */
  130.     final public static function encodePrimaryKey(EntityDefinition $definition, array $primaryKey, Context $context): array
  131.     {
  132.         $fields = $definition->getPrimaryKeys();
  134.         $mapped = [];
  136.         $existence = new EntityExistence($definition->getEntityName(), [], true, false, false, []);
  138.         $params = new WriteParameterBag($definition, WriteContext::createFromContext($context), '', new WriteCommandQueue());
  140.         foreach ($fields as $field) {
  141.             if ($field instanceof VersionField || $field instanceof ReferenceVersionField) {
  142.                 $value = $context->getVersionId();
  143.             } else {
  144.                 $value = $primaryKey[$field->getPropertyName()];
  145.             }
  147.             $kvPair = new KeyValuePair($field->getPropertyName(), $value, true);
  149.             $encoded = $field->getSerializer()->encode($field, $existence, $kvPair, $params);
  151.             foreach ($encoded as $key => $value) {
  152.                 $mapped[$key] = $value;
  153.             }
  154.         }
  156.         return $mapped;
  157.     }
  159.     /**
  160.      * Allows simple overwrite for specialized entity hydrators
  161.      *
  162.      * @param array<mixed> $row
  163.      */
  164.     protected function assign(EntityDefinition $definition, Entity $entity, string $root, array $row, Context $context): Entity
  165.     {
  166.         $entity = $this->hydrateFields($definition, $entity, $root, $row, $context, $definition->getFields());
  168.         return $entity;
  169.     }
  171.     /**
  172.      * @param array<mixed> $row
  173.      * @param iterable<Field> $fields
  174.      */
  175.     protected function hydrateFields(EntityDefinition $definition, Entity $entity, string $root, array $row, Context $context, iterable $fields): Entity
  176.     {
  177.         /** @var ArrayStruct<string, mixed> $foreignKeys */
  178.         $foreignKeys = $entity->getExtension(EntityReader::FOREIGN_KEYS);
  179.         $isPartial = self::$partial !== [];
  181.         foreach ($fields as $field) {
  182.             $property = $field->getPropertyName();
  184.             if ($isPartial && !isset(self::$partial[$property])) {
  185.                 continue;
  186.             }
  188.             $key = $root . '.' . $property;
  190.             // initialize not loaded associations with null
  191.             if ($field instanceof AssociationField && $entity instanceof ArrayEntity) {
  192.                 $entity->set($property, null);
  193.             }
  195.             if ($field instanceof ParentAssociationField) {
  196.                 continue;
  197.             }
  199.             if ($field instanceof ManyToManyAssociationField) {
  200.                 $this->manyToMany($row, $root, $entity, $field);
  202.                 continue;
  203.             }
  205.             if ($field instanceof ManyToOneAssociationField || $field instanceof OneToOneAssociationField) {
  206.                 $association = $this->manyToOne($row, $root, $field, $context);
  208.                 if ($association === null && $entity instanceof PartialEntity) {
  209.                     continue;
  210.                 }
  212.                 if ($field->is(Extension::class)) {
  213.                     if ($association) {
  214.                         $entity->addExtension($property, $association);
  215.                     }
  216.                 } else {
  217.                     $entity->assign([$property => $association]);
  218.                 }
  220.                 continue;
  221.             }
  223.             //other association fields are not handled in entity reader query
  224.             if ($field instanceof AssociationField) {
  225.                 continue;
  226.             }
  228.             if (!\array_key_exists($key, $row)) {
  229.                 continue;
  230.             }
  232.             $value = $row[$key];
  234.             $typed = $field;
  235.             if ($field instanceof TranslatedField) {
  236.                 $typed = EntityDefinitionQueryHelper::getTranslatedField($definition, $field);
  237.             }
  239.             if ($typed instanceof CustomFields) {
  240.                 $this->customFields($definition, $row, $root, $entity, $field, $context);
  242.                 continue;
  243.             }
  245.             if ($field instanceof TranslatedField) {
  246.                 // contains the resolved translation chain value
  247.                 $decoded = $typed->getSerializer()->decode($typed, $value);
  248.                 $entity->addTranslated($property, $decoded);
  250.                 $inherited = $definition->isInheritanceAware() && $context->considerInheritance();
  251.                 $chain = EntityDefinitionQueryHelper::buildTranslationChain($root, $context, $inherited);
  253.                 // assign translated value of the first language
  254.                 $key = array_shift($chain) . '.' . $property;
  256.                 $decoded = $typed->getSerializer()->decode($typed, $row[$key]);
  257.                 $entity->assign([$property => $decoded]);
  259.                 continue;
  260.             }
  262.             $decoded = $definition->decode($property, $value);
  264.             if ($field->is(Extension::class)) {
  265.                 $foreignKeys->set($property, $decoded);
  266.             } else {
  267.                 $entity->assign([$property => $decoded]);
  268.             }
  269.         }
  271.         return $entity;
  272.     }
  274.     /**
  275.      * @param array<mixed> $row
  276.      */
  277.     protected function manyToMany(array $row, string $root, Entity $entity, ?Field $field): void
  278.     {
  279.         if ($field === null) {
  280.             throw new \RuntimeException('No field provided');
  281.         }
  283.         $accessor = $root . '.' . $field->getPropertyName() . '.id_mapping';
  285.         //many to many isn't loaded in case of limited association criterias
  286.         if (!\array_key_exists($accessor, $row)) {
  287.             return;
  288.         }
  290.         //explode hexed ids
  291.         $ids = explode('||', (string) $row[$accessor]);
  293.         $ids = array_map('strtolower', array_filter($ids));
  295.         /** @var ArrayStruct<string, mixed> $mapping */
  296.         $mapping = $entity->getExtension(EntityReader::INTERNAL_MAPPING_STORAGE);
  298.         $mapping->set($field->getPropertyName(), $ids);
  299.     }
  301.     /**
  302.      * @param array<mixed> $row
  303.      * @param array<string, Field> $fields
  304.      */
  305.     protected function translate(EntityDefinition $definition, Entity $entity, array $row, string $root, Context $context, array $fields): void
  306.     {
  307.         $inherited = $definition->isInheritanceAware() && $context->considerInheritance();
  309.         $chain = EntityDefinitionQueryHelper::buildTranslationChain($root, $context, $inherited);
  311.         $translatedFields = $this->getTranslatedFields($definition, $fields);
  313.         foreach ($translatedFields as $field => $typed) {
  314.             $entity->addTranslated($field, $typed->getSerializer()->decode($typed, self::value($row, $root, $field)));
  316.             $entity->$field = $typed->getSerializer()->decode($typed, self::value($row, $chain[0], $field));
  317.         }
  318.     }
  320.     /**
  321.      * @param array<Field> $fields
  322.      *
  323.      * @return array<string, Field>
  324.      */
  325.     protected function getTranslatedFields(EntityDefinition $definition, array $fields): array
  326.     {
  327.         $key = $definition->getEntityName();
  328.         if (isset(self::$translatedFields[$key])) {
  329.             return self::$translatedFields[$key];
  330.         }
  332.         $translatedFields = [];
  333.         /** @var TranslatedField $field */
  334.         foreach ($fields as $field) {
  335.             $translatedFields[$field->getPropertyName()] = EntityDefinitionQueryHelper::getTranslatedField($definition, $field);
  336.         }
  338.         return self::$translatedFields[$key] = $translatedFields;
  339.     }
  341.     /**
  342.      * @param array<mixed> $row
  343.      */
  344.     protected function manyToOne(array $row, string $root, ?Field $field, Context $context): ?Entity
  345.     {
  346.         if ($field === null) {
  347.             throw new \RuntimeException('No field provided');
  348.         }
  350.         if (!$field instanceof AssociationField) {
  351.             throw new \RuntimeException(sprintf('Provided field %s is no association field', $field->getPropertyName()));
  352.         }
  353.         $pk = $this->getManyToOneProperty($field);
  355.         $association = $root . '.' . $field->getPropertyName();
  357.         $key = $association . '.' . $pk;
  359.         if (!isset($row[$key])) {
  360.             return null;
  361.         }
  363.         return $this->hydrateEntity($field->getReferenceDefinition(), $field->getReferenceDefinition()->getEntityClass(), $row, $association, $context, self::$partial[$field->getPropertyName()] ?? []);
  364.     }
  366.     /**
  367.      * @param array<mixed> $row
  368.      */
  369.     protected function customFields(EntityDefinition $definition, array $row, string $root, Entity $entity, ?Field $field, Context $context): void
  370.     {
  371.         if ($field === null) {
  372.             return;
  373.         }
  375.         $inherited = $field->is(Inherited::class) && $context->considerInheritance();
  377.         $propertyName = $field->getPropertyName();
  379.         $value = self::value($row, $root, $propertyName);
  381.         if ($field instanceof TranslatedField) {
  382.             $customField = EntityDefinitionQueryHelper::getTranslatedField($definition, $field);
  384.             $chain = EntityDefinitionQueryHelper::buildTranslationChain($root, $context, $inherited);
  386.             $decoded = $customField->getSerializer()->decode($customField, self::value($row, $chain[0], $propertyName));
  388.             $entity->assign([$propertyName => $decoded]);
  390.             $values = [];
  391.             foreach ($chain as $accessor) {
  392.                 $values[] = self::value($row, $accessor, $propertyName);
  393.             }
  395.             if (empty($values)) {
  396.                 return;
  397.             }
  399.             /**
  400.              * `array_merge`s ordering is reversed compared to the translations array.
  401.              * In other terms: The first argument has the lowest 'priority', so we need to reverse the array
  402.              */
  403.             $merged = $this->mergeJson(array_reverse($values, false));
  404.             $decoded = $customField->getSerializer()->decode($customField, $merged);
  405.             $entity->addTranslated($propertyName, $decoded);
  407.             if ($inherited) {
  408.                 /*
  409.                  * The translations chains array has the structure: [
  410.                  *      main language,
  411.                  *      parent with main language,
  412.                  *      fallback language,
  413.                  *      parent with fallback language,
  414.                  * ]
  415.                  *
  416.                  * We need to join the first two to get the inherited field value of the main translation
  417.                  */
  418.                 $values = [
  419.                     self::value($row, $chain[0], $propertyName),
  420.                     self::value($row, $chain[1], $propertyName),
  421.                 ];
  423.                 $merged = $this->mergeJson(array_reverse($values, false));
  424.                 $decoded = $customField->getSerializer()->decode($customField, $merged);
  425.                 $entity->assign([$propertyName => $decoded]);
  426.             }
  428.             return;
  429.         }
  431.         // field is not inherited or request should work with raw data? decode child attributes and return
  432.         if (!$inherited) {
  433.             $value = $field->getSerializer()->decode($field, $value);
  434.             $entity->assign([$propertyName => $value]);
  436.             return;
  437.         }
  439.         $parentKey = $root . '.' . $propertyName . '.inherited';
  441.         // parent has no attributes? decode only child attributes and return
  442.         if (!isset($row[$parentKey])) {
  443.             $value = $field->getSerializer()->decode($field, $value);
  445.             $entity->assign([$propertyName => $value]);
  447.             return;
  448.         }
  450.         // merge child attributes with parent attributes and assign
  451.         $mergedJson = $this->mergeJson([$row[$parentKey], $value]);
  453.         $merged = $field->getSerializer()->decode($field, $mergedJson);
  455.         $entity->assign([$propertyName => $merged]);
  456.     }
  458.     /**
  459.      * @param array<mixed> $row
  460.      */
  461.     protected static function value(array $row, string $root, string $property): ?string
  462.     {
  463.         $accessor = $root . '.' . $property;
  465.         return $row[$accessor] ?? null;
  466.     }
  468.     protected function getManyToOneProperty(AssociationField $field): string
  469.     {
  470.         $key = $field->getReferenceDefinition()->getEntityName() . '.' . $field->getReferenceField();
  471.         if (isset(self::$manyToOne[$key])) {
  472.             return self::$manyToOne[$key];
  473.         }
  475.         $reference = $field->getReferenceDefinition()->getFields()->getByStorageName(
  476.             $field->getReferenceField()
  477.         );
  479.         if ($reference === null) {
  480.             throw new \RuntimeException(sprintf(
  481.                 'Can not find field by storage name %s in definition %s',
  482.                 $field->getReferenceField(),
  483.                 $field->getReferenceDefinition()->getEntityName()
  484.             ));
  485.         }
  487.         return self::$manyToOne[$key] = $reference->getPropertyName();
  488.     }
  490.     /**
  491.      * @param array<string|null> $jsonStrings
  492.      */
  493.     protected function mergeJson(array $jsonStrings): string
  494.     {
  495.         $merged = [];
  496.         foreach ($jsonStrings as $string) {
  497.             if ($string === null) {
  498.                 continue;
  499.             }
  501.             $decoded = json_decode($string, true, 512, \JSON_THROW_ON_ERROR);
  503.             if (!$decoded) {
  504.                 continue;
  505.             }
  507.             foreach ($decoded as $key => $value) {
  508.                 if ($value === null) {
  509.                     continue;
  510.                 }
  512.                 $merged[$key] = $value;
  513.             }
  514.         }
  516.         return json_encode($merged, \JSON_PRESERVE_ZERO_FRACTION | \JSON_THROW_ON_ERROR);
  517.     }
  519.     /**
  520.      * @param array<mixed> $row
  521.      * @param array<string|array<string>> $partial
  522.      */
  523.     private function hydrateEntity(EntityDefinition $definition, string $entityClass, array $row, string $root, Context $context, array $partial = []): Entity
  524.     {
  525.         $isPartial = $partial !== [];
  526.         $hydratorClass = $definition->getHydratorClass();
  527.         $entityClass = $isPartial ? PartialEntity::class : $entityClass;
  529.         if ($isPartial) {
  530.             $hydratorClass = EntityHydrator::class;
  531.         }
  533.         $hydrator = $this->container->get($hydratorClass);
  535.         if (!$hydrator instanceof self) {
  536.             throw new \RuntimeException(sprintf('Hydrator for entity %s not registered', $definition->getEntityName()));
  537.         }
  539.         $identifier = implode('-', self::buildUniqueIdentifier($definition, $row, $root));
  541.         $cacheKey = $root . '::' . $identifier;
  543.         if (isset(self::$hydrated[$cacheKey])) {
  544.             return self::$hydrated[$cacheKey];
  545.         }
  547.         $entity = new $entityClass();
  549.         if (!$entity instanceof Entity) {
  550.             throw new \RuntimeException(sprintf('Expected instance of Entity.php, got %s', $entity::class));
  551.         }
  553.         $entity->addExtension(EntityReader::FOREIGN_KEYS, new ArrayStruct([], $definition->getEntityName() . '_foreign_keys_extension'));
  554.         $entity->addExtension(EntityReader::INTERNAL_MAPPING_STORAGE, new ArrayStruct());
  556.         $entity->setUniqueIdentifier($identifier);
  557.         $entity->internalSetEntityData($definition->getEntityName(), $definition->getFieldVisibility());
  559.         $entity = $hydrator->assign($definition, $entity, $root, $row, $context);
  561.         return self::$hydrated[$cacheKey] = $entity;
  562.     }
  563. }