vendor/shopware/core/Framework/DataAbstractionLayer/Dbal/EntityReader.php line 92

Open in your IDE?
  1. <?php declare(strict_types=1);
  2. namespace Shopware\Core\Framework\DataAbstractionLayer\Dbal;
  3. use Doctrine\DBAL\Connection;
  4. use Psr\Log\LoggerInterface;
  5. use Shopware\Core\Framework\Context;
  6. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\Exception\ParentAssociationCanNotBeFetched;
  7. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\FetchModeHelper;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Entity;
  9. use Shopware\Core\Framework\DataAbstractionLayer\EntityCollection;
  10. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Field\AssociationField;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Field\ChildrenAssociationField;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Field\Field;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\CascadeDelete;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Extension;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Inherited;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\PrimaryKey;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Runtime;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Field\JsonField;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToManyAssociationField;
  21. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToManyIdField;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToOneAssociationField;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Field\OneToManyAssociationField;
  24. use Shopware\Core\Framework\DataAbstractionLayer\Field\OneToOneAssociationField;
  25. use Shopware\Core\Framework\DataAbstractionLayer\Field\ParentAssociationField;
  26. use Shopware\Core\Framework\DataAbstractionLayer\Field\StorageAware;
  27. use Shopware\Core\Framework\DataAbstractionLayer\Field\TranslatedField;
  28. use Shopware\Core\Framework\DataAbstractionLayer\FieldCollection;
  29. use Shopware\Core\Framework\DataAbstractionLayer\Read\EntityReaderInterface;
  30. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  31. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsAnyFilter;
  32. use Shopware\Core\Framework\DataAbstractionLayer\Search\Parser\SqlQueryParser;
  33. use Shopware\Core\Framework\DataAbstractionLayer\Search\Sorting\FieldSorting;
  34. use Shopware\Core\Framework\Struct\ArrayEntity;
  35. use Shopware\Core\Framework\Struct\ArrayStruct;
  36. use Shopware\Core\Framework\Uuid\Uuid;
  37. use function array_filter;
  38. /**
  39.  * @deprecated tag:v6.5.0 - reason:becomes-internal - Will be internal
  40.  */
  41. class EntityReader implements EntityReaderInterface
  42. {
  43.     public const INTERNAL_MAPPING_STORAGE 'internal_mapping_storage';
  44.     public const FOREIGN_KEYS 'foreignKeys';
  45.     public const MANY_TO_MANY_LIMIT_QUERY 'many_to_many_limit_query';
  46.     private Connection $connection;
  47.     private EntityHydrator $hydrator;
  48.     private EntityDefinitionQueryHelper $queryHelper;
  49.     private SqlQueryParser $parser;
  50.     private CriteriaQueryBuilder $criteriaQueryBuilder;
  51.     private LoggerInterface $logger;
  52.     public function __construct(
  53.         Connection $connection,
  54.         EntityHydrator $hydrator,
  55.         EntityDefinitionQueryHelper $queryHelper,
  56.         SqlQueryParser $parser,
  57.         CriteriaQueryBuilder $criteriaQueryBuilder,
  58.         LoggerInterface $logger
  59.     ) {
  60.         $this->connection $connection;
  61.         $this->hydrator $hydrator;
  62.         $this->queryHelper $queryHelper;
  63.         $this->parser $parser;
  64.         $this->criteriaQueryBuilder $criteriaQueryBuilder;
  65.         $this->logger $logger;
  66.     }
  67.     /**
  68.      * @return EntityCollection<Entity>
  69.      */
  70.     public function read(EntityDefinition $definitionCriteria $criteriaContext $context): EntityCollection
  71.     {
  72.         $criteria->resetSorting();
  73.         $criteria->resetQueries();
  74.         /** @var EntityCollection<Entity> $collectionClass */
  75.         $collectionClass $definition->getCollectionClass();
  76.         $fields $this->buildCriteriaFields($criteria$definition);
  77.         return $this->_read(
  78.             $criteria,
  79.             $definition,
  80.             $context,
  81.             new $collectionClass(),
  82.             $definition->getFields()->getBasicFields(),
  83.             true,
  84.             $fields
  85.         );
  86.     }
  87.     protected function getParser(): SqlQueryParser
  88.     {
  89.         return $this->parser;
  90.     }
  91.     /**
  92.      * @param EntityCollection<Entity> $collection
  93.      *
  94.      * @return EntityCollection<Entity>
  95.      */
  96.     private function _read(
  97.         Criteria $criteria,
  98.         EntityDefinition $definition,
  99.         Context $context,
  100.         EntityCollection $collection,
  101.         FieldCollection $fields,
  102.         bool $performEmptySearch false,
  103.         array $partial = []
  104.     ): EntityCollection {
  105.         $hasFilters = !empty($criteria->getFilters()) || !empty($criteria->getPostFilters());
  106.         $hasIds = !empty($criteria->getIds());
  107.         if (!$performEmptySearch && !$hasFilters && !$hasIds) {
  108.             return $collection;
  109.         }
  110.         if ($partial !== []) {
  111.             $fields $definition->getFields()->filter(function (Field $field) use (&$partial) {
  112.                 if ($field->getFlag(PrimaryKey::class) || $field instanceof ManyToManyIdField) {
  113.                     $partial[$field->getPropertyName()] = [];
  114.                     return true;
  115.                 }
  116.                 return isset($partial[$field->getPropertyName()]);
  117.             });
  118.         }
  119.         // always add the criteria fields to the collection, otherwise we have conflicts between criteria.fields and criteria.association logic
  120.         $fields $this->addAssociationFieldsToCriteria($criteria$definition$fields);
  121.         if ($definition->isInheritanceAware() && $criteria->hasAssociation('parent')) {
  122.             throw new ParentAssociationCanNotBeFetched();
  123.         }
  124.         $rows $this->fetch($criteria$definition$context$fields$partial);
  125.         $collection $this->hydrator->hydrate($collection$definition->getEntityClass(), $definition$rows$definition->getEntityName(), $context$partial);
  126.         $collection $this->fetchAssociations($criteria$definition$context$collection$fields$partial);
  127.         $hasIds = !empty($criteria->getIds());
  128.         if ($hasIds && empty($criteria->getSorting())) {
  129.             $collection->sortByIdArray($criteria->getIds());
  130.         }
  131.         return $collection;
  132.     }
  133.     private function joinBasic(
  134.         EntityDefinition $definition,
  135.         Context $context,
  136.         string $root,
  137.         QueryBuilder $query,
  138.         FieldCollection $fields,
  139.         ?Criteria $criteria null,
  140.         array $partial = []
  141.     ): void {
  142.         $isPartial $partial !== [];
  143.         $filtered $fields->filter(static function (Field $field) use ($isPartial$partial) {
  144.             if ($field->is(Runtime::class)) {
  145.                 return false;
  146.             }
  147.             if (!$isPartial || $field->getFlag(PrimaryKey::class)) {
  148.                 return true;
  149.             }
  150.             return isset($partial[$field->getPropertyName()]);
  151.         });
  152.         $parentAssociation null;
  153.         if ($definition->isInheritanceAware() && $context->considerInheritance()) {
  154.             $parentAssociation $definition->getFields()->get('parent');
  155.             if ($parentAssociation !== null) {
  156.                 $this->queryHelper->resolveField($parentAssociation$definition$root$query$context);
  157.             }
  158.         }
  159.         $addTranslation false;
  160.         /** @var Field $field */
  161.         foreach ($filtered as $field) {
  162.             //translated fields are handled after loop all together
  163.             if ($field instanceof TranslatedField) {
  164.                 $this->queryHelper->resolveField($field$definition$root$query$context);
  165.                 $addTranslation true;
  166.                 continue;
  167.             }
  168.             //self references can not be resolved if set to autoload, otherwise we get an endless loop
  169.             if (!$field instanceof ParentAssociationField && $field instanceof AssociationField && $field->getAutoload() && $field->getReferenceDefinition() === $definition) {
  170.                 continue;
  171.             }
  172.             //many to one associations can be directly fetched in same query
  173.             if ($field instanceof ManyToOneAssociationField || $field instanceof OneToOneAssociationField) {
  174.                 $reference $field->getReferenceDefinition();
  175.                 $basics $reference->getFields()->getBasicFields();
  176.                 $this->queryHelper->resolveField($field$definition$root$query$context);
  177.                 $alias $root '.' $field->getPropertyName();
  178.                 $joinCriteria null;
  179.                 if ($criteria && $criteria->hasAssociation($field->getPropertyName())) {
  180.                     $joinCriteria $criteria->getAssociation($field->getPropertyName());
  181.                     $basics $this->addAssociationFieldsToCriteria($joinCriteria$reference$basics);
  182.                 }
  183.                 $this->joinBasic($reference$context$alias$query$basics$joinCriteria$partial[$field->getPropertyName()] ?? []);
  184.                 continue;
  185.             }
  186.             //add sub select for many to many field
  187.             if ($field instanceof ManyToManyAssociationField) {
  188.                 if ($this->isAssociationRestricted($criteria$field->getPropertyName())) {
  189.                     continue;
  190.                 }
  191.                 //requested a paginated, filtered or sorted list
  192.                 $this->addManyToManySelect($definition$root$field$query$context);
  193.                 continue;
  194.             }
  195.             //other associations like OneToManyAssociationField fetched lazy by additional query
  196.             if ($field instanceof AssociationField) {
  197.                 continue;
  198.             }
  199.             if ($parentAssociation !== null
  200.                 && $field instanceof StorageAware
  201.                 && $field->is(Inherited::class)
  202.                 && $context->considerInheritance()
  203.             ) {
  204.                 $parentAlias $root '.' $parentAssociation->getPropertyName();
  205.                 //contains the field accessor for the child value (eg. `product.name`.`name`)
  206.                 $childAccessor EntityDefinitionQueryHelper::escape($root) . '.'
  207.                     EntityDefinitionQueryHelper::escape($field->getStorageName());
  208.                 //contains the field accessor for the parent value (eg. `product.parent`.`name`)
  209.                 $parentAccessor EntityDefinitionQueryHelper::escape($parentAlias) . '.'
  210.                     EntityDefinitionQueryHelper::escape($field->getStorageName());
  211.                 //contains the alias for the resolved field (eg. `product.name`)
  212.                 $fieldAlias EntityDefinitionQueryHelper::escape($root '.' $field->getPropertyName());
  213.                 if ($field instanceof JsonField) {
  214.                     // merged in hydrator
  215.                     $parentFieldAlias EntityDefinitionQueryHelper::escape($root '.' $field->getPropertyName() . '.inherited');
  216.                     $query->addSelect(sprintf('%s as %s'$parentAccessor$parentFieldAlias));
  217.                 }
  218.                 //add selection for resolved parent-child inheritance field
  219.                 $query->addSelect(sprintf('COALESCE(%s, %s) as %s'$childAccessor$parentAccessor$fieldAlias));
  220.                 continue;
  221.             }
  222.             //all other StorageAware fields are stored inside the main entity
  223.             if ($field instanceof StorageAware) {
  224.                 $query->addSelect(
  225.                     EntityDefinitionQueryHelper::escape($root) . '.'
  226.                     EntityDefinitionQueryHelper::escape($field->getStorageName()) . ' as '
  227.                     EntityDefinitionQueryHelper::escape($root '.' $field->getPropertyName())
  228.                 );
  229.             }
  230.         }
  231.         if ($addTranslation) {
  232.             $this->queryHelper->addTranslationSelect($root$definition$query$context$partial);
  233.         }
  234.     }
  235.     private function fetch(Criteria $criteriaEntityDefinition $definitionContext $contextFieldCollection $fields, array $partial = []): array
  236.     {
  237.         $table $definition->getEntityName();
  238.         $query $this->criteriaQueryBuilder->build(
  239.             new QueryBuilder($this->connection),
  240.             $definition,
  241.             $criteria,
  242.             $context
  243.         );
  244.         $this->joinBasic($definition$context$table$query$fields$criteria$partial);
  245.         if (!empty($criteria->getIds())) {
  246.             $this->queryHelper->addIdCondition($criteria$definition$query);
  247.         }
  248.         if ($criteria->getTitle()) {
  249.             $query->setTitle($criteria->getTitle() . '::read');
  250.         }
  251.         return $query->execute()->fetchAll();
  252.     }
  253.     /**
  254.      * @param EntityCollection<Entity> $collection
  255.      */
  256.     private function loadManyToMany(
  257.         Criteria $criteria,
  258.         ManyToManyAssociationField $association,
  259.         Context $context,
  260.         EntityCollection $collection,
  261.         array $partial
  262.     ): void {
  263.         $associationCriteria $criteria->getAssociation($association->getPropertyName());
  264.         if (!$associationCriteria->getTitle() && $criteria->getTitle()) {
  265.             $associationCriteria->setTitle(
  266.                 $criteria->getTitle() . '::association::' $association->getPropertyName()
  267.             );
  268.         }
  269.         //check if the requested criteria is restricted (limit, offset, sorting, filtering)
  270.         if ($this->isAssociationRestricted($criteria$association->getPropertyName())) {
  271.             //if restricted load paginated list of many to many
  272.             $this->loadManyToManyWithCriteria($associationCriteria$association$context$collection$partial);
  273.             return;
  274.         }
  275.         //otherwise the association is loaded in the root query of the entity as sub select which contains all ids
  276.         //the ids are extracted in the entity hydrator (see: \Shopware\Core\Framework\DataAbstractionLayer\Dbal\EntityHydrator::extractManyToManyIds)
  277.         $this->loadManyToManyOverExtension($associationCriteria$association$context$collection$partial);
  278.     }
  279.     private function addManyToManySelect(
  280.         EntityDefinition $definition,
  281.         string $root,
  282.         ManyToManyAssociationField $field,
  283.         QueryBuilder $query,
  284.         Context $context
  285.     ): void {
  286.         $mapping $field->getMappingDefinition();
  287.         $versionCondition '';
  288.         if ($mapping->isVersionAware() && $definition->isVersionAware() && $field->is(CascadeDelete::class)) {
  289.             $versionField $definition->getEntityName() . '_version_id';
  290.             $versionCondition ' AND #alias#.' $versionField ' = #root#.version_id';
  291.         }
  292.         $source EntityDefinitionQueryHelper::escape($root) . '.' EntityDefinitionQueryHelper::escape($field->getLocalField());
  293.         if ($field->is(Inherited::class) && $context->considerInheritance()) {
  294.             $source EntityDefinitionQueryHelper::escape($root) . '.' EntityDefinitionQueryHelper::escape($field->getPropertyName());
  295.         }
  296.         $parameters = [
  297.             '#alias#' => EntityDefinitionQueryHelper::escape($root '.' $field->getPropertyName() . '.mapping'),
  298.             '#mapping_reference_column#' => EntityDefinitionQueryHelper::escape($field->getMappingReferenceColumn()),
  299.             '#mapping_table#' => EntityDefinitionQueryHelper::escape($mapping->getEntityName()),
  300.             '#mapping_local_column#' => EntityDefinitionQueryHelper::escape($field->getMappingLocalColumn()),
  301.             '#root#' => EntityDefinitionQueryHelper::escape($root),
  302.             '#source#' => $source,
  303.             '#property#' => EntityDefinitionQueryHelper::escape($root '.' $field->getPropertyName() . '.id_mapping'),
  304.         ];
  305.         $query->addSelect(
  306.             str_replace(
  307.                 array_keys($parameters),
  308.                 array_values($parameters),
  309.                 '(SELECT GROUP_CONCAT(HEX(#alias#.#mapping_reference_column#) SEPARATOR \'||\')
  310.                   FROM #mapping_table# #alias#
  311.                   WHERE #alias#.#mapping_local_column# = #source#'
  312.                   $versionCondition
  313.                   ' ) as #property#'
  314.             )
  315.         );
  316.     }
  317.     /**
  318.      * @param EntityCollection<Entity> $collection
  319.      */
  320.     private function collectManyToManyIds(EntityCollection $collectionAssociationField $association): array
  321.     {
  322.         $ids = [];
  323.         $property $association->getPropertyName();
  324.         /** @var Entity $struct */
  325.         foreach ($collection as $struct) {
  326.             /** @var ArrayStruct<string, mixed> $ext */
  327.             $ext $struct->getExtension(self::INTERNAL_MAPPING_STORAGE);
  328.             /** @var array<string> $tmp */
  329.             $tmp $ext->get($property);
  330.             foreach ($tmp as $id) {
  331.                 $ids[] = $id;
  332.             }
  333.         }
  334.         return $ids;
  335.     }
  336.     /**
  337.      * @param EntityCollection<Entity> $collection
  338.      */
  339.     private function loadOneToMany(
  340.         Criteria $criteria,
  341.         EntityDefinition $definition,
  342.         OneToManyAssociationField $association,
  343.         Context $context,
  344.         EntityCollection $collection,
  345.         array $partial
  346.     ): void {
  347.         $fieldCriteria = new Criteria();
  348.         if ($criteria->hasAssociation($association->getPropertyName())) {
  349.             $fieldCriteria $criteria->getAssociation($association->getPropertyName());
  350.         }
  351.         if (!$fieldCriteria->getTitle() && $criteria->getTitle()) {
  352.             $fieldCriteria->setTitle(
  353.                 $criteria->getTitle() . '::association::' $association->getPropertyName()
  354.             );
  355.         }
  356.         //association should not be paginated > load data over foreign key condition
  357.         if ($fieldCriteria->getLimit() === null) {
  358.             $this->loadOneToManyWithoutPagination($definition$association$context$collection$fieldCriteria$partial);
  359.             return;
  360.         }
  361.         //load association paginated > use internal counter loops
  362.         $this->loadOneToManyWithPagination($definition$association$context$collection$fieldCriteria$partial);
  363.     }
  364.     /**
  365.      * @param EntityCollection<Entity> $collection
  366.      */
  367.     private function loadOneToManyWithoutPagination(
  368.         EntityDefinition $definition,
  369.         OneToManyAssociationField $association,
  370.         Context $context,
  371.         EntityCollection $collection,
  372.         Criteria $fieldCriteria,
  373.         array $partial
  374.     ): void {
  375.         $ref $association->getReferenceDefinition()->getFields()->getByStorageName(
  376.             $association->getReferenceField()
  377.         );
  378.         \assert($ref instanceof Field);
  379.         $propertyName $ref->getPropertyName();
  380.         if ($association instanceof ChildrenAssociationField) {
  381.             $propertyName 'parentId';
  382.         }
  383.         //build orm property accessor to add field sortings and conditions `customer_address.customerId`
  384.         $propertyAccessor $association->getReferenceDefinition()->getEntityName() . '.' $propertyName;
  385.         $ids array_values($collection->getIds());
  386.         $isInheritanceAware $definition->isInheritanceAware() && $context->considerInheritance();
  387.         if ($isInheritanceAware) {
  388.             $parentIds array_values(array_filter($collection->map(function (Entity $entity) {
  389.                 return $entity->get('parentId');
  390.             })));
  391.             $ids array_unique(array_merge($ids$parentIds));
  392.         }
  393.         $fieldCriteria->addFilter(new EqualsAnyFilter($propertyAccessor$ids));
  394.         $referenceClass $association->getReferenceDefinition();
  395.         /** @var EntityCollection<Entity> $collectionClass */
  396.         $collectionClass $referenceClass->getCollectionClass();
  397.         if ($partial !== []) {
  398.             // Make sure our collection index will be loaded
  399.             $partial[$propertyName] = [];
  400.             $collectionClass EntityCollection::class;
  401.         }
  402.         $data $this->_read(
  403.             $fieldCriteria,
  404.             $referenceClass,
  405.             $context,
  406.             new $collectionClass(),
  407.             $referenceClass->getFields()->getBasicFields(),
  408.             false,
  409.             $partial
  410.         );
  411.         $grouped = [];
  412.         foreach ($data as $entity) {
  413.             $fk $entity->get($propertyName);
  414.             $grouped[$fk][] = $entity;
  415.         }
  416.         //assign loaded data to root entities
  417.         foreach ($collection as $entity) {
  418.             $structData = new $collectionClass();
  419.             if (isset($grouped[$entity->getUniqueIdentifier()])) {
  420.                 $structData->fill($grouped[$entity->getUniqueIdentifier()]);
  421.             }
  422.             //assign data of child immediately
  423.             if ($association->is(Extension::class)) {
  424.                 $entity->addExtension($association->getPropertyName(), $structData);
  425.             } else {
  426.                 //otherwise the data will be assigned directly as properties
  427.                 $entity->assign([$association->getPropertyName() => $structData]);
  428.             }
  429.             if (!$association->is(Inherited::class) || $structData->count() > || !$context->considerInheritance()) {
  430.                 continue;
  431.             }
  432.             //if association can be inherited by the parent and the struct data is empty, filter again for the parent id
  433.             $structData = new $collectionClass();
  434.             if (isset($grouped[$entity->get('parentId')])) {
  435.                 $structData->fill($grouped[$entity->get('parentId')]);
  436.             }
  437.             if ($association->is(Extension::class)) {
  438.                 $entity->addExtension($association->getPropertyName(), $structData);
  439.                 continue;
  440.             }
  441.             $entity->assign([$association->getPropertyName() => $structData]);
  442.         }
  443.     }
  444.     /**
  445.      * @param EntityCollection<Entity> $collection
  446.      */
  447.     private function loadOneToManyWithPagination(
  448.         EntityDefinition $definition,
  449.         OneToManyAssociationField $association,
  450.         Context $context,
  451.         EntityCollection $collection,
  452.         Criteria $fieldCriteria,
  453.         array $partial
  454.     ): void {
  455.         $isPartial $partial !== [];
  456.         $propertyAccessor $this->buildOneToManyPropertyAccessor($definition$association);
  457.         // inject sorting for foreign key, otherwise the internal counter wouldn't work `order by customer_address.customer_id, other_sortings`
  458.         $sorting array_merge(
  459.             [new FieldSorting($propertyAccessorFieldSorting::ASCENDING)],
  460.             $fieldCriteria->getSorting()
  461.         );
  462.         $fieldCriteria->resetSorting();
  463.         $fieldCriteria->addSorting(...$sorting);
  464.         $ids array_values($collection->getIds());
  465.         if ($isPartial) {
  466.             // Make sure our collection index will be loaded
  467.             $partial[$association->getPropertyName()] = [];
  468.         }
  469.         $isInheritanceAware $definition->isInheritanceAware() && $context->considerInheritance();
  470.         if ($isInheritanceAware) {
  471.             $parentIds array_values(array_filter($collection->map(function (Entity $entity) {
  472.                 return $entity->get('parentId');
  473.             })));
  474.             $ids array_unique(array_merge($ids$parentIds));
  475.         }
  476.         $fieldCriteria->addFilter(new EqualsAnyFilter($propertyAccessor$ids));
  477.         $mapping $this->fetchPaginatedOneToManyMapping($definition$association$context$collection$fieldCriteria);
  478.         $ids = [];
  479.         foreach ($mapping as $associationIds) {
  480.             foreach ($associationIds as $associationId) {
  481.                 $ids[] = $associationId;
  482.             }
  483.         }
  484.         $fieldCriteria->setIds(array_filter($ids));
  485.         $fieldCriteria->resetSorting();
  486.         $fieldCriteria->resetFilters();
  487.         $fieldCriteria->resetPostFilters();
  488.         $referenceClass $association->getReferenceDefinition();
  489.         /** @var EntityCollection<Entity> $collectionClass */
  490.         $collectionClass $referenceClass->getCollectionClass();
  491.         $data $this->_read(
  492.             $fieldCriteria,
  493.             $referenceClass,
  494.             $context,
  495.             new $collectionClass(),
  496.             $referenceClass->getFields()->getBasicFields(),
  497.             false,
  498.             $partial
  499.         );
  500.         //assign loaded reference collections to root entities
  501.         /** @var Entity $entity */
  502.         foreach ($collection as $entity) {
  503.             //extract mapping ids for the current entity
  504.             $mappingIds $mapping[$entity->getUniqueIdentifier()];
  505.             $structData $data->getList($mappingIds);
  506.             //assign data of child immediately
  507.             if ($association->is(Extension::class)) {
  508.                 $entity->addExtension($association->getPropertyName(), $structData);
  509.             } else {
  510.                 $entity->assign([$association->getPropertyName() => $structData]);
  511.             }
  512.             if (!$association->is(Inherited::class) || $structData->count() > || !$context->considerInheritance()) {
  513.                 continue;
  514.             }
  515.             $parentId $entity->get('parentId');
  516.             if ($parentId === null) {
  517.                 continue;
  518.             }
  519.             //extract mapping ids for the current entity
  520.             $mappingIds $mapping[$parentId];
  521.             $structData $data->getList($mappingIds);
  522.             //assign data of child immediately
  523.             if ($association->is(Extension::class)) {
  524.                 $entity->addExtension($association->getPropertyName(), $structData);
  525.             } else {
  526.                 $entity->assign([$association->getPropertyName() => $structData]);
  527.             }
  528.         }
  529.     }
  530.     /**
  531.      * @param EntityCollection<Entity> $collection
  532.      */
  533.     private function loadManyToManyOverExtension(
  534.         Criteria $criteria,
  535.         ManyToManyAssociationField $association,
  536.         Context $context,
  537.         EntityCollection $collection,
  538.         array $partial
  539.     ): void {
  540.         //collect all ids of many to many association which already stored inside the struct instances
  541.         $ids $this->collectManyToManyIds($collection$association);
  542.         $criteria->setIds($ids);
  543.         $referenceClass $association->getToManyReferenceDefinition();
  544.         /** @var EntityCollection<Entity> $collectionClass */
  545.         $collectionClass $referenceClass->getCollectionClass();
  546.         $data $this->_read(
  547.             $criteria,
  548.             $referenceClass,
  549.             $context,
  550.             new $collectionClass(),
  551.             $referenceClass->getFields()->getBasicFields(),
  552.             false,
  553.             $partial
  554.         );
  555.         /** @var Entity $struct */
  556.         foreach ($collection as $struct) {
  557.             /** @var ArrayEntity $extension */
  558.             $extension $struct->getExtension(self::INTERNAL_MAPPING_STORAGE);
  559.             //use assign function to avoid setter name building
  560.             $structData $data->getList(
  561.                 $extension->get($association->getPropertyName())
  562.             );
  563.             //if the association is added as extension (for plugins), we have to add the data as extension
  564.             if ($association->is(Extension::class)) {
  565.                 $struct->addExtension($association->getPropertyName(), $structData);
  566.             } else {
  567.                 $struct->assign([$association->getPropertyName() => $structData]);
  568.             }
  569.         }
  570.     }
  571.     /**
  572.      * @param EntityCollection<Entity> $collection
  573.      */
  574.     private function loadManyToManyWithCriteria(
  575.         Criteria $fieldCriteria,
  576.         ManyToManyAssociationField $association,
  577.         Context $context,
  578.         EntityCollection $collection,
  579.         array $partial
  580.     ): void {
  581.         $fields $association->getToManyReferenceDefinition()->getFields();
  582.         $reference null;
  583.         foreach ($fields as $field) {
  584.             if (!$field instanceof ManyToManyAssociationField) {
  585.                 continue;
  586.             }
  587.             if ($field->getReferenceDefinition() !== $association->getReferenceDefinition()) {
  588.                 continue;
  589.             }
  590.             $reference $field;
  591.             break;
  592.         }
  593.         if (!$reference) {
  594.             throw new \RuntimeException(
  595.                 sprintf(
  596.                     'No inverse many to many association found, for association %s',
  597.                     $association->getPropertyName()
  598.                 )
  599.             );
  600.         }
  601.         //build inverse accessor `product.categories.id`
  602.         $accessor $association->getToManyReferenceDefinition()->getEntityName() . '.' $reference->getPropertyName() . '.id';
  603.         $fieldCriteria->addFilter(new EqualsAnyFilter($accessor$collection->getIds()));
  604.         $root EntityDefinitionQueryHelper::escape(
  605.             $association->getToManyReferenceDefinition()->getEntityName() . '.' $reference->getPropertyName() . '.mapping'
  606.         );
  607.         $query = new QueryBuilder($this->connection);
  608.         // to many selects results in a `group by` clause. In this case the order by parts will be executed with MIN/MAX aggregation
  609.         // but at this point the order by will be moved to an sub select where we don't have a group state, the `state` prevents this behavior
  610.         $query->addState(self::MANY_TO_MANY_LIMIT_QUERY);
  611.         $query $this->criteriaQueryBuilder->build(
  612.             $query,
  613.             $association->getToManyReferenceDefinition(),
  614.             $fieldCriteria,
  615.             $context
  616.         );
  617.         $localColumn EntityDefinitionQueryHelper::escape($association->getMappingLocalColumn());
  618.         $referenceColumn EntityDefinitionQueryHelper::escape($association->getMappingReferenceColumn());
  619.         $orderBy '';
  620.         $parts $query->getQueryPart('orderBy');
  621.         if (!empty($parts)) {
  622.             $orderBy ' ORDER BY ' implode(', '$parts);
  623.             $query->resetQueryPart('orderBy');
  624.         }
  625.         // order by is handled in group_concat
  626.         $fieldCriteria->resetSorting();
  627.         $query->select([
  628.             'LOWER(HEX(' $root '.' $localColumn ')) as `key`',
  629.             'GROUP_CONCAT(LOWER(HEX(' $root '.' $referenceColumn ')) ' $orderBy ') as `value`',
  630.         ]);
  631.         $query->addGroupBy($root '.' $localColumn);
  632.         if ($fieldCriteria->getLimit() !== null) {
  633.             $limitQuery $this->buildManyToManyLimitQuery($association);
  634.             $params = [
  635.                 '#source_column#' => EntityDefinitionQueryHelper::escape($association->getMappingLocalColumn()),
  636.                 '#reference_column#' => EntityDefinitionQueryHelper::escape($association->getMappingReferenceColumn()),
  637.                 '#table#' => $root,
  638.             ];
  639.             $query->innerJoin(
  640.                 $root,
  641.                 '(' $limitQuery ')',
  642.                 'counter_table',
  643.                 str_replace(
  644.                     array_keys($params),
  645.                     array_values($params),
  646.                     'counter_table.#source_column# = #table#.#source_column# AND
  647.                      counter_table.#reference_column# = #table#.#reference_column# AND
  648.                      counter_table.id_count <= :limit'
  649.                 )
  650.             );
  651.             $query->setParameter('limit'$fieldCriteria->getLimit());
  652.             $this->connection->executeQuery('SET @n = 0; SET @c = null;');
  653.         }
  654.         $mapping $query->execute()->fetchAll();
  655.         $mapping FetchModeHelper::keyPair($mapping);
  656.         $ids = [];
  657.         foreach ($mapping as &$row) {
  658.             $row array_filter(explode(','$row));
  659.             foreach ($row as $id) {
  660.                 $ids[] = $id;
  661.             }
  662.         }
  663.         unset($row);
  664.         $fieldCriteria->setIds($ids);
  665.         $referenceClass $association->getToManyReferenceDefinition();
  666.         /** @var EntityCollection<Entity> $collectionClass */
  667.         $collectionClass $referenceClass->getCollectionClass();
  668.         $data $this->_read(
  669.             $fieldCriteria,
  670.             $referenceClass,
  671.             $context,
  672.             new $collectionClass(),
  673.             $referenceClass->getFields()->getBasicFields(),
  674.             false,
  675.             $partial
  676.         );
  677.         /** @var Entity $struct */
  678.         foreach ($collection as $struct) {
  679.             $structData = new $collectionClass();
  680.             $id $struct->getUniqueIdentifier();
  681.             $parentId $struct->has('parentId') ? $struct->get('parentId') : '';
  682.             if (\array_key_exists($struct->getUniqueIdentifier(), $mapping)) {
  683.                 //filter mapping list of whole data array
  684.                 $structData $data->getList($mapping[$id]);
  685.                 //sort list by ids if the criteria contained a sorting
  686.                 $structData->sortByIdArray($mapping[$id]);
  687.             } elseif (\array_key_exists($parentId$mapping) && $association->is(Inherited::class) && $context->considerInheritance()) {
  688.                 //filter mapping for the inherited parent association
  689.                 $structData $data->getList($mapping[$parentId]);
  690.                 //sort list by ids if the criteria contained a sorting
  691.                 $structData->sortByIdArray($mapping[$parentId]);
  692.             }
  693.             //if the association is added as extension (for plugins), we have to add the data as extension
  694.             if ($association->is(Extension::class)) {
  695.                 $struct->addExtension($association->getPropertyName(), $structData);
  696.             } else {
  697.                 $struct->assign([$association->getPropertyName() => $structData]);
  698.             }
  699.         }
  700.     }
  701.     /**
  702.      * @param EntityCollection<Entity> $collection
  703.      */
  704.     private function fetchPaginatedOneToManyMapping(
  705.         EntityDefinition $definition,
  706.         OneToManyAssociationField $association,
  707.         Context $context,
  708.         EntityCollection $collection,
  709.         Criteria $fieldCriteria
  710.     ): array {
  711.         $sortings $fieldCriteria->getSorting();
  712.         // Remove first entry
  713.         array_shift($sortings);
  714.         //build query based on provided association criteria (sortings, search, filter)
  715.         $query $this->criteriaQueryBuilder->build(
  716.             new QueryBuilder($this->connection),
  717.             $association->getReferenceDefinition(),
  718.             $fieldCriteria,
  719.             $context
  720.         );
  721.         $foreignKey $association->getReferenceField();
  722.         if (!$association->getReferenceDefinition()->getField('id')) {
  723.             throw new \RuntimeException(
  724.                 sprintf(
  725.                     'Paginated to many association must have an id field. No id field found for association %s.%s',
  726.                     $definition->getEntityName(),
  727.                     $association->getPropertyName()
  728.                 )
  729.             );
  730.         }
  731.         //build sql accessor for foreign key field in reference table `customer_address.customer_id`
  732.         $sqlAccessor EntityDefinitionQueryHelper::escape($association->getReferenceDefinition()->getEntityName()) . '.'
  733.             EntityDefinitionQueryHelper::escape($foreignKey);
  734.         $query->select(
  735.             [
  736.                 //build select with an internal counter loop, the counter loop will be reset if the foreign key changed (this is the reason for the sorting inject above)
  737.                 '@n:=IF(@c=' $sqlAccessor ', @n+1, IF(@c:=' $sqlAccessor ',1,1)) as id_count',
  738.                 //add select for foreign key for join condition
  739.                 $sqlAccessor,
  740.                 //add primary key select to group concat them
  741.                 EntityDefinitionQueryHelper::escape($association->getReferenceDefinition()->getEntityName()) . '.id',
  742.             ]
  743.         );
  744.         foreach ($query->getQueryPart('orderBy') as $i => $sorting) {
  745.             // The first order is the primary key
  746.             if ($i === 0) {
  747.                 continue;
  748.             }
  749.             --$i;
  750.             // Strip the ASC/DESC at the end of the sort
  751.             $query->addSelect(\sprintf('%s as sort_%s'substr($sorting0, -4), $i));
  752.         }
  753.         $root EntityDefinitionQueryHelper::escape($definition->getEntityName());
  754.         //create a wrapper query which select the root primary key and the grouped reference ids
  755.         $wrapper $this->connection->createQueryBuilder();
  756.         $wrapper->select(
  757.             [
  758.                 'LOWER(HEX(' $root '.id)) as id',
  759.                 'LOWER(HEX(child.id)) as child_id',
  760.             ]
  761.         );
  762.         foreach ($sortings as $i => $sorting) {
  763.             $wrapper->addOrderBy(sprintf('sort_%s'$i), $sorting->getDirection());
  764.         }
  765.         $wrapper->from($root$root);
  766.         //wrap query into a sub select to restrict the association count from the outer query
  767.         $wrapper->leftJoin(
  768.             $root,
  769.             '(' $query->getSQL() . ')',
  770.             'child',
  771.             'child.' $foreignKey ' = ' $root '.id AND id_count >= :offset AND id_count <= :limit'
  772.         );
  773.         //filter result to loaded root entities
  774.         $wrapper->andWhere($root '.id IN (:rootIds)');
  775.         $bytes $collection->map(
  776.             function (Entity $entity) {
  777.                 return Uuid::fromHexToBytes($entity->getUniqueIdentifier());
  778.             }
  779.         );
  780.         if ($definition->isInheritanceAware() && $context->considerInheritance()) {
  781.             /** @var Entity $entity */
  782.             foreach ($collection->getElements() as $entity) {
  783.                 if ($entity->get('parentId')) {
  784.                     $bytes[$entity->get('parentId')] = Uuid::fromHexToBytes($entity->get('parentId'));
  785.                 }
  786.             }
  787.         }
  788.         $wrapper->setParameter('rootIds'$bytesConnection::PARAM_STR_ARRAY);
  789.         $limit $fieldCriteria->getOffset() + $fieldCriteria->getLimit();
  790.         $offset $fieldCriteria->getOffset() + 1;
  791.         $wrapper->setParameter('limit'$limit);
  792.         $wrapper->setParameter('offset'$offset);
  793.         foreach ($query->getParameters() as $key => $value) {
  794.             $type $query->getParameterType($key);
  795.             $wrapper->setParameter($key$value$type);
  796.         }
  797.         //initials the cursor and loop counter, pdo do not allow to execute SET and SELECT in one statement
  798.         $this->connection->executeQuery('SET @n = 0; SET @c = null;');
  799.         $rows $wrapper->execute()->fetchAll();
  800.         $grouped = [];
  801.         foreach ($rows as $row) {
  802.             $id $row['id'];
  803.             if (!isset($grouped[$id])) {
  804.                 $grouped[$id] = [];
  805.             }
  806.             if (empty($row['child_id'])) {
  807.                 continue;
  808.             }
  809.             $grouped[$id][] = $row['child_id'];
  810.         }
  811.         return $grouped;
  812.     }
  813.     private function buildManyToManyLimitQuery(ManyToManyAssociationField $association): QueryBuilder
  814.     {
  815.         $table EntityDefinitionQueryHelper::escape($association->getMappingDefinition()->getEntityName());
  816.         $sourceColumn EntityDefinitionQueryHelper::escape($association->getMappingLocalColumn());
  817.         $referenceColumn EntityDefinitionQueryHelper::escape($association->getMappingReferenceColumn());
  818.         $params = [
  819.             '#table#' => $table,
  820.             '#source_column#' => $sourceColumn,
  821.         ];
  822.         $query = new QueryBuilder($this->connection);
  823.         $query->select([
  824.             str_replace(
  825.                 array_keys($params),
  826.                 array_values($params),
  827.                 '@n:=IF(@c=#table#.#source_column#, @n+1, IF(@c:=#table#.#source_column#,1,1)) as id_count'
  828.             ),
  829.             $table '.' $referenceColumn,
  830.             $table '.' $sourceColumn,
  831.         ]);
  832.         $query->from($table$table);
  833.         $query->orderBy($table '.' $sourceColumn);
  834.         return $query;
  835.     }
  836.     private function buildOneToManyPropertyAccessor(EntityDefinition $definitionOneToManyAssociationField $association): string
  837.     {
  838.         $reference $association->getReferenceDefinition();
  839.         if ($association instanceof ChildrenAssociationField) {
  840.             return $reference->getEntityName() . '.parentId';
  841.         }
  842.         $ref $reference->getFields()->getByStorageName(
  843.             $association->getReferenceField()
  844.         );
  845.         if (!$ref) {
  846.             throw new \RuntimeException(
  847.                 sprintf(
  848.                     'Reference field %s not found in definition %s for definition %s',
  849.                     $association->getReferenceField(),
  850.                     $reference->getEntityName(),
  851.                     $definition->getEntityName()
  852.                 )
  853.             );
  854.         }
  855.         return $reference->getEntityName() . '.' $ref->getPropertyName();
  856.     }
  857.     private function isAssociationRestricted(?Criteria $criteriastring $accessor): bool
  858.     {
  859.         if ($criteria === null) {
  860.             return false;
  861.         }
  862.         if (!$criteria->hasAssociation($accessor)) {
  863.             return false;
  864.         }
  865.         $fieldCriteria $criteria->getAssociation($accessor);
  866.         return $fieldCriteria->getOffset() !== null
  867.             || $fieldCriteria->getLimit() !== null
  868.             || !empty($fieldCriteria->getSorting())
  869.             || !empty($fieldCriteria->getFilters())
  870.             || !empty($fieldCriteria->getPostFilters())
  871.         ;
  872.     }
  873.     private function addAssociationFieldsToCriteria(
  874.         Criteria $criteria,
  875.         EntityDefinition $definition,
  876.         FieldCollection $fields
  877.     ): FieldCollection {
  878.         foreach ($criteria->getAssociations() as $fieldName => $_fieldCriteria) {
  879.             $field $definition->getFields()->get($fieldName);
  880.             if (!$field) {
  881.                 $this->logger->warning(
  882.                     sprintf('Criteria association "%s" could not be resolved. Double check your Criteria!'$fieldName)
  883.                 );
  884.                 continue;
  885.             }
  886.             $fields->add($field);
  887.         }
  888.         return $fields;
  889.     }
  890.     /**
  891.      * @param EntityCollection<Entity> $collection
  892.      */
  893.     private function loadToOne(
  894.         AssociationField $association,
  895.         Context $context,
  896.         EntityCollection $collection,
  897.         Criteria $criteria,
  898.         array $partial
  899.     ): void {
  900.         if (!$association instanceof OneToOneAssociationField && !$association instanceof ManyToOneAssociationField) {
  901.             return;
  902.         }
  903.         if (!$criteria->hasAssociation($association->getPropertyName())) {
  904.             return;
  905.         }
  906.         $associationCriteria $criteria->getAssociation($association->getPropertyName());
  907.         if (!$associationCriteria->getAssociations()) {
  908.             return;
  909.         }
  910.         if (!$associationCriteria->getTitle() && $criteria->getTitle()) {
  911.             $associationCriteria->setTitle(
  912.                 $criteria->getTitle() . '::association::' $association->getPropertyName()
  913.             );
  914.         }
  915.         $related array_filter($collection->map(function (Entity $entity) use ($association) {
  916.             if ($association->is(Extension::class)) {
  917.                 return $entity->getExtension($association->getPropertyName());
  918.             }
  919.             return $entity->get($association->getPropertyName());
  920.         }));
  921.         $referenceDefinition $association->getReferenceDefinition();
  922.         $collectionClass $referenceDefinition->getCollectionClass();
  923.         if ($partial !== []) {
  924.             $collectionClass EntityCollection::class;
  925.         }
  926.         $fields $referenceDefinition->getFields()->getBasicFields();
  927.         $fields $this->addAssociationFieldsToCriteria($associationCriteria$referenceDefinition$fields);
  928.         // This line removes duplicate entries, so after fetchAssociations the association must be reassigned
  929.         $relatedCollection = new $collectionClass();
  930.         if (!$relatedCollection instanceof EntityCollection) {
  931.             throw new \RuntimeException(sprintf('Collection class %s has to be an instance of EntityCollection'$collectionClass));
  932.         }
  933.         $relatedCollection->fill($related);
  934.         $this->fetchAssociations($associationCriteria$referenceDefinition$context$relatedCollection$fields$partial);
  935.         /** @var Entity $entity */
  936.         foreach ($collection as $entity) {
  937.             if ($association->is(Extension::class)) {
  938.                 $item $entity->getExtension($association->getPropertyName());
  939.             } else {
  940.                 $item $entity->get($association->getPropertyName());
  941.             }
  942.             /** @var Entity|null $item */
  943.             if ($item === null) {
  944.                 continue;
  945.             }
  946.             if ($association->is(Extension::class)) {
  947.                 $entity->addExtension($association->getPropertyName(), $relatedCollection->get($item->getUniqueIdentifier()));
  948.                 continue;
  949.             }
  950.             $entity->assign([
  951.                 $association->getPropertyName() => $relatedCollection->get($item->getUniqueIdentifier()),
  952.             ]);
  953.         }
  954.     }
  955.     /**
  956.      * @param EntityCollection<Entity> $collection
  957.      *
  958.      * @return EntityCollection<Entity>
  959.      */
  960.     private function fetchAssociations(
  961.         Criteria $criteria,
  962.         EntityDefinition $definition,
  963.         Context $context,
  964.         EntityCollection $collection,
  965.         FieldCollection $fields,
  966.         array $partial
  967.     ): EntityCollection {
  968.         if ($collection->count() <= 0) {
  969.             return $collection;
  970.         }
  971.         foreach ($fields as $association) {
  972.             if (!$association instanceof AssociationField) {
  973.                 continue;
  974.             }
  975.             if ($association instanceof OneToOneAssociationField || $association instanceof ManyToOneAssociationField) {
  976.                 $this->loadToOne($association$context$collection$criteria$partial[$association->getPropertyName()] ?? []);
  977.                 continue;
  978.             }
  979.             if ($association instanceof OneToManyAssociationField) {
  980.                 $this->loadOneToMany($criteria$definition$association$context$collection$partial[$association->getPropertyName()] ?? []);
  981.                 continue;
  982.             }
  983.             if ($association instanceof ManyToManyAssociationField) {
  984.                 $this->loadManyToMany($criteria$association$context$collection$partial[$association->getPropertyName()] ?? []);
  985.             }
  986.         }
  987.         foreach ($collection as $struct) {
  988.             $struct->removeExtension(self::INTERNAL_MAPPING_STORAGE);
  989.         }
  990.         return $collection;
  991.     }
  992.     private function addAssociationsToCriteriaFields(Criteria $criteria, array &$fields): void
  993.     {
  994.         if ($fields === []) {
  995.             return;
  996.         }
  997.         foreach ($criteria->getAssociations() as $fieldName => $fieldCriteria) {
  998.             if (!isset($fields[$fieldName])) {
  999.                 $fields[$fieldName] = [];
  1000.             }
  1001.             $this->addAssociationsToCriteriaFields($fieldCriteria$fields[$fieldName]);
  1002.         }
  1003.     }
  1004.     private function buildCriteriaFields(Criteria $criteriaEntityDefinition $definition): array
  1005.     {
  1006.         if (empty($criteria->getFields())) {
  1007.             return [];
  1008.         }
  1009.         $fields = [];
  1010.         $this->addAssociationsToCriteriaFields($criteria$fields);
  1011.         foreach ($criteria->getFields() as $field) {
  1012.             $association EntityDefinitionQueryHelper::getFieldsOfAccessor($definition$fieldtrue);
  1013.             if ($association !== [] && $association[0] instanceof AssociationField) {
  1014.                 $criteria->addAssociation($field);
  1015.             }
  1016.             $pointer = &$fields;
  1017.             foreach (explode('.'$field) as $part) {
  1018.                 if (!isset($pointer[$part])) {
  1019.                     $pointer[$part] = [];
  1020.                 }
  1021.                 $pointer = &$pointer[$part];
  1022.             }
  1023.         }
  1024.         return $fields;
  1025.     }
  1026. }