src/Core/Framework/DataAbstractionLayer/Dbal/EntityWriteGateway.php line 97

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer\Dbal;
  5. use Doctrine\DBAL\Connection;
  6. use Doctrine\DBAL\Exception;
  7. use Doctrine\DBAL\Query\QueryBuilder as DbalQueryBuilderAlias;
  8. use Doctrine\DBAL\Types\Types;
  9. use Shopware\Core\Framework\DataAbstractionLayer\DefinitionInstanceRegistry;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\MultiInsertQueryQueue;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\RetryableQuery;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\RetryableTransaction;
  13. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  14. use Shopware\Core\Framework\DataAbstractionLayer\EntityTranslationDefinition;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Event\BeforeDeleteEvent;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Exception\CanNotFindParentStorageFieldException;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Exception\InvalidParentAssociationException;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Exception\ParentFieldForeignKeyConstraintMissingException;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Exception\ParentFieldNotFoundException;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Exception\PrimaryKeyNotProvidedException;
  21. use Shopware\Core\Framework\DataAbstractionLayer\Exception\UnsupportedCommandTypeException;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Field\Field;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Field\FkField;
  24. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToOneAssociationField;
  25. use Shopware\Core\Framework\DataAbstractionLayer\Field\StorageAware;
  26. use Shopware\Core\Framework\DataAbstractionLayer\Field\VersionField;
  27. use Shopware\Core\Framework\DataAbstractionLayer\MappingEntityDefinition;
  28. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\ChangeSet;
  29. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\ChangeSetAware;
  30. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\DeleteCommand;
  31. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\InsertCommand;
  32. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\JsonUpdateCommand;
  33. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\UpdateCommand;
  34. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\WriteCommand;
  35. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\WriteCommandQueue;
  36. use Shopware\Core\Framework\DataAbstractionLayer\Write\EntityExistence;
  37. use Shopware\Core\Framework\DataAbstractionLayer\Write\EntityWriteGatewayInterface;
  38. use Shopware\Core\Framework\DataAbstractionLayer\Write\PrimaryKeyBag;
  39. use Shopware\Core\Framework\DataAbstractionLayer\Write\Validation\PostWriteValidationEvent;
  40. use Shopware\Core\Framework\DataAbstractionLayer\Write\Validation\PreWriteValidationEvent;
  41. use Shopware\Core\Framework\DataAbstractionLayer\Write\Validation\WriteCommandExceptionEvent;
  42. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteContext;
  43. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteParameterBag;
  44. use Shopware\Core\Framework\Log\Package;
  45. use Shopware\Core\Framework\Uuid\Uuid;
  46. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  48. /**
  49.  * @internal
  50.  */
  51. #[Package('core')]
  52. class EntityWriteGateway implements EntityWriteGatewayInterface
  53. {
  54.     private ?PrimaryKeyBag $primaryKeyBag = null;
  56.     public function __construct(private readonly int $batchSize, private readonly Connection $connection, private readonly EventDispatcherInterface $eventDispatcher, private readonly ExceptionHandlerRegistry $exceptionHandlerRegistry, private readonly DefinitionInstanceRegistry $definitionInstanceRegistry)
  57.     {
  58.     }
  60.     public function prefetchExistences(WriteParameterBag $parameters): void
  61.     {
  62.         $primaryKeyBag = $this->primaryKeyBag = $parameters->getPrimaryKeyBag();
  64.         if ($primaryKeyBag->isPrefetchingCompleted()) {
  65.             return;
  66.         }
  68.         foreach ($primaryKeyBag->getPrimaryKeys() as $entity => $pks) {
  69.             $this->prefetch($this->definitionInstanceRegistry->getByEntityName($entity), $pks, $parameters);
  70.         }
  72.         $primaryKeyBag->setPrefetchingCompleted(true);
  73.     }
  75.     /**
  76.      * {@inheritdoc}
  77.      */
  78.     public function getExistence(EntityDefinition $definition, array $primaryKey, array $data, WriteCommandQueue $commandQueue): EntityExistence
  79.     {
  80.         $state = $this->getCurrentState($definition, $primaryKey, $commandQueue);
  82.         $exists = !empty($state);
  84.         $isChild = $this->isChild($definition, $data, $state, $primaryKey, $commandQueue);
  86.         $wasChild = $this->wasChild($definition, $state);
  88.         return new EntityExistence($definition->getEntityName(), Uuid::fromBytesToHexList($primaryKey), $exists, $isChild, $wasChild, $state);
  89.     }
  91.     /**
  92.      * {@inheritdoc}
  93.      */
  94.     public function execute(array $commands, WriteContext $context): void
  95.     {
  96.         try {
  97.             RetryableTransaction::retryable($this->connection, function () use ($commands, $context): void {
  98.                 $this->executeCommands($commands, $context);
  99.             });
  100.         } catch (\Throwable $e) {
  101.             $event = new WriteCommandExceptionEvent($e, $commands, $context->getContext());
  102.             $this->eventDispatcher->dispatch($event);
  104.             throw $e;
  105.         }
  106.     }
  108.     /**
  109.      * @param list<WriteCommand> $commands
  110.      */
  111.     private function executeCommands(array $commands, WriteContext $context): void
  112.     {
  113.         $beforeDeleteEvent = BeforeDeleteEvent::create($context, $commands);
  115.         if ($beforeDeleteEvent->filled()) {
  116.             $this->eventDispatcher->dispatch($beforeDeleteEvent);
  117.         }
  119.         // throws exception on violation and then aborts/rollbacks this transaction
  120.         $event = new PreWriteValidationEvent($context, $commands);
  121.         $this->eventDispatcher->dispatch($event);
  123.         $this->generateChangeSets($commands);
  125.         $context->getExceptions()->tryToThrow();
  127.         $previous = null;
  128.         $mappings = new MultiInsertQueryQueue($this->connection, $this->batchSize, false, true);
  129.         $inserts = new MultiInsertQueryQueue($this->connection, $this->batchSize);
  131.         $executeInserts = function () use ($mappings, $inserts): void {
  132.             $mappings->execute();
  133.             $inserts->execute();
  134.         };
  136.         try {
  137.             foreach ($commands as $command) {
  138.                 if (!$command->isValid()) {
  139.                     continue;
  140.                 }
  141.                 $command->setFailed(false);
  142.                 $current = $command->getDefinition()->getEntityName();
  144.                 if ($current !== $previous) {
  145.                     $executeInserts();
  146.                 }
  147.                 $previous = $current;
  149.                 try {
  150.                     $definition = $command->getDefinition();
  151.                     $table = $definition->getEntityName();
  153.                     if ($command instanceof DeleteCommand) {
  154.                         $executeInserts();
  156.                         RetryableQuery::retryable($this->connection, function () use ($command, $table): void {
  157.                             $this->connection->delete(EntityDefinitionQueryHelper::escape($table), $command->getPrimaryKey());
  158.                         });
  160.                         continue;
  161.                     }
  163.                     if ($command instanceof JsonUpdateCommand) {
  164.                         $executeInserts();
  165.                         $this->executeJsonUpdate($command);
  167.                         continue;
  168.                     }
  170.                     if ($definition instanceof MappingEntityDefinition && $command instanceof InsertCommand) {
  171.                         $mappings->addInsert($definition->getEntityName(), $command->getPayload());
  173.                         continue;
  174.                     }
  176.                     if ($command instanceof UpdateCommand) {
  177.                         $executeInserts();
  179.                         RetryableQuery::retryable($this->connection, function () use ($command, $table): void {
  180.                             $this->connection->update(
  181.                                 EntityDefinitionQueryHelper::escape($table),
  182.                                 $this->escapeColumnKeys($command->getPayload()),
  183.                                 $command->getPrimaryKey()
  184.                             );
  185.                         });
  187.                         continue;
  188.                     }
  190.                     if ($command instanceof InsertCommand) {
  191.                         $inserts->addInsert($definition->getEntityName(), $command->getPayload());
  193.                         continue;
  194.                     }
  196.                     throw new UnsupportedCommandTypeException($command);
  197.                 } catch (\Exception $e) {
  198.                     $command->setFailed(true);
  200.                     $innerException = $this->exceptionHandlerRegistry->matchException($e);
  202.                     if ($innerException instanceof \Exception) {
  203.                         $e = $innerException;
  204.                     }
  205.                     $context->getExceptions()->add($e);
  207.                     throw $e;
  208.                 }
  209.             }
  211.             $mappings->execute();
  212.             $inserts->execute();
  213.             $beforeDeleteEvent->success();
  214.         } catch (Exception $e) {
  215.             // Match exception without passing a specific command when feature-flag 16640 is active
  216.             $innerException = $this->exceptionHandlerRegistry->matchException($e);
  217.             if ($innerException instanceof \Exception) {
  218.                 $e = $innerException;
  219.             }
  220.             $context->getExceptions()->add($e);
  222.             $beforeDeleteEvent->error();
  224.             throw $e;
  225.         }
  227.         // throws exception on violation and then aborts/rollbacks this transaction
  228.         $event = new PostWriteValidationEvent($context, $commands);
  229.         $this->eventDispatcher->dispatch($event);
  230.         $context->getExceptions()->tryToThrow();
  231.     }
  233.     /**
  234.      * @param list<array<string, string>> $pks
  235.      */
  236.     private function prefetch(EntityDefinition $definition, array $pks, WriteParameterBag $parameters): void
  237.     {
  238.         $pkFields = [];
  239.         $versionField = null;
  240.         /** @var StorageAware&Field $field */
  241.         foreach ($definition->getPrimaryKeys() as $field) {
  242.             if ($field instanceof VersionField) {
  243.                 $versionField = $field;
  245.                 continue;
  246.             }
  247.             if ($field instanceof StorageAware) {
  248.                 $pkFields[$field->getStorageName()] = $field;
  249.             }
  250.         }
  252.         $query = $this->connection->createQueryBuilder();
  253.         $query->from(EntityDefinitionQueryHelper::escape($definition->getEntityName()));
  254.         $query->addSelect('1 as `exists`');
  256.         if ($definition->isChildrenAware()) {
  257.             $query->addSelect('parent_id');
  258.         } elseif ($definition->isInheritanceAware()) {
  259.             $parent = $this->getParentField($definition);
  261.             if ($parent !== null) {
  262.                 $query->addSelect(
  263.                     EntityDefinitionQueryHelper::escape($parent->getStorageName())
  264.                     . ' as `parent`'
  265.                 );
  266.             }
  267.         }
  269.         foreach ($pkFields as $storageName => $_) {
  270.             $query->addSelect(EntityDefinitionQueryHelper::escape($storageName));
  271.         }
  272.         if ($versionField) {
  273.             $query->addSelect(EntityDefinitionQueryHelper::escape($versionField->getStorageName()));
  274.         }
  276.         $chunks = array_chunk($pks, 500, true);
  278.         foreach ($chunks as $pks) {
  279.             $query->resetQueryPart('where');
  281.             $params = [];
  282.             $tupleCount = 0;
  284.             foreach ($pks as $pk) {
  285.                 $newIds = [];
  286.                 /** @var Field&StorageAware $field */
  287.                 foreach ($pkFields as $field) {
  288.                     $id = $pk[$field->getPropertyName()] ?? null;
  289.                     if ($id === null) {
  290.                         continue 2;
  291.                     }
  292.                     $newIds[] = Uuid::fromHexToBytes($id);
  293.                 }
  295.                 foreach ($newIds as $newId) {
  296.                     $params[] = $newId;
  297.                 }
  299.                 ++$tupleCount;
  300.             }
  302.             if ($tupleCount <= 0) {
  303.                 continue;
  304.             }
  306.             $placeholders = $this->getPlaceholders(\count($pkFields), $tupleCount);
  307.             $columns = '`' . implode('`,`', array_keys($pkFields)) . '`';
  308.             if (\count($pkFields) > 1) {
  309.                 $columns = '(' . $columns . ')';
  310.             }
  312.             $query->andWhere($columns . ' IN (' . $placeholders . ')');
  313.             if ($versionField) {
  314.                 $query->andWhere('version_id = ?');
  315.                 $params[] = Uuid::fromHexToBytes($parameters->getContext()->getContext()->getVersionId());
  316.             }
  318.             $query->setParameters($params);
  320.             $result = $query->executeQuery()->fetchAllAssociative();
  322.             $primaryKeyBag = $parameters->getPrimaryKeyBag();
  324.             foreach ($result as $state) {
  325.                 $values = [];
  326.                 foreach ($pkFields as $storageKey => $field) {
  327.                     $values[$field->getPropertyName()] = Uuid::fromBytesToHex($state[$storageKey]);
  328.                 }
  329.                 if ($versionField) {
  330.                     $values[$versionField->getPropertyName()] = $parameters->getContext()->getContext()->getVersionId();
  331.                 }
  333.                 $primaryKeyBag->addExistenceState($definition, $values, $state);
  334.             }
  336.             foreach ($pks as $pk) {
  337.                 if (!$primaryKeyBag->hasExistence($definition, $pk)) {
  338.                     $primaryKeyBag->addExistenceState($definition, $pk, []);
  339.                 }
  340.             }
  341.         }
  342.     }
  344.     /**
  345.      * @param array<mixed> $array
  346.      */
  347.     private static function isAssociative(array $array): bool
  348.     {
  349.         foreach ($array as $key => $_value) {
  350.             if (!\is_int($key)) {
  351.                 return true;
  352.             }
  353.         }
  355.         return false;
  356.     }
  358.     private function executeJsonUpdate(JsonUpdateCommand $command): void
  359.     {
  360.         /*
  361.          * mysql json functions are tricky.
  362.          *
  363.          * TL;DR: cast objects and arrays to json
  364.          *
  365.          * This works:
  366.          *
  367.          * SELECT JSON_SET('{"a": "b"}', '$.a', 7)
  368.          * SELECT JSON_SET('{"a": "b"}', '$.a', "str")
  369.          *
  370.          * This does NOT work:
  371.          *
  372.          * SELECT JSON_SET('{"a": "b"}', '$.a', '{"foo": "bar"}')
  373.          *
  374.          * Instead, you have to do this, because mysql cannot differentiate between a string and a json string:
  375.          *
  376.          * SELECT JSON_SET('{"a": "b"}', '$.a', CAST('{"foo": "bar"}' AS json))
  377.          * SELECT JSON_SET('{"a": "b"}', '$.a', CAST('["foo", "bar"]' AS json))
  378.          *
  379.          * Yet this does NOT work:
  380.          *
  381.          * SELECT JSON_SET('{"a": "b"}', '$.a', CAST("str" AS json))
  382.          *
  383.          */
  385.         $values = [];
  386.         $sets = [];
  387.         $types = [];
  389.         $query = new QueryBuilder($this->connection);
  390.         $query->update('`' . $command->getDefinition()->getEntityName() . '`');
  392.         foreach ($command->getPayload() as $attribute => $value) {
  393.             // add path and value for each attribute value pair
  394.             $values[] = '$."' . $attribute . '"';
  395.             $types[] = Types::STRING;
  396.             if (\is_array($value) || \is_object($value)) {
  397.                 $types[] = Types::STRING;
  398.                 $values[] = json_encode($value, \JSON_PRESERVE_ZERO_FRACTION | \JSON_UNESCAPED_UNICODE);
  399.                 // does the same thing as CAST(?, json) but works on mariadb
  400.                 $identityValue = \is_object($value) || self::isAssociative($value) ? '{}' : '[]';
  401.                 $sets[] = '?, JSON_MERGE("' . $identityValue . '", ?)';
  402.             } else {
  403.                 if (!\is_bool($value)) {
  404.                     $values[] = $value;
  405.                 }
  407.                 $set = '?, ?';
  409.                 if (\is_float($value)) {
  410.                     $types[] = \PDO::PARAM_STR;
  411.                     $set = '?, ? + 0.0';
  412.                 } elseif (\is_int($value)) {
  413.                     $types[] = \PDO::PARAM_INT;
  414.                 } elseif (\is_bool($value)) {
  415.                     $set = '?, ' . ($value ? 'true' : 'false');
  416.                 } else {
  417.                     $types[] = \PDO::PARAM_STR;
  418.                 }
  420.                 $sets[] = $set;
  421.             }
  422.         }
  424.         $storageName = $command->getStorageName();
  425.         $query->set(
  426.             $storageName,
  427.             sprintf(
  428.                 'JSON_SET(IFNULL(%s, "{}"), %s)',
  429.                 EntityDefinitionQueryHelper::escape($storageName),
  430.                 implode(', ', $sets)
  431.             )
  432.         );
  434.         $identifier = $command->getPrimaryKey();
  435.         foreach ($identifier as $key => $_value) {
  436.             $query->andWhere(EntityDefinitionQueryHelper::escape($key) . ' = ?');
  437.         }
  438.         $query->setParameters([...$values, ...array_values($identifier)], $types);
  440.         RetryableQuery::retryable($this->connection, function () use ($query): void {
  441.             $query->executeStatement();
  442.         });
  443.     }
  445.     /**
  446.      * @param array<string, mixed> $payload
  447.      *
  448.      * @return array<string, mixed>
  449.      */
  450.     private function escapeColumnKeys(array $payload): array
  451.     {
  452.         $escaped = [];
  453.         foreach ($payload as $key => $value) {
  454.             $escaped[EntityDefinitionQueryHelper::escape($key)] = $value;
  455.         }
  457.         return $escaped;
  458.     }
  460.     /**
  461.      * @param list<WriteCommand> $commands
  462.      */
  463.     private function generateChangeSets(array $commands): void
  464.     {
  465.         $primaryKeys = [];
  466.         $definitions = [];
  468.         foreach ($commands as $command) {
  469.             if (!$command instanceof ChangeSetAware || !$command instanceof WriteCommand) {
  470.                 continue;
  471.             }
  473.             if (!$command->requiresChangeSet()) {
  474.                 continue;
  475.             }
  477.             $entity = $command->getDefinition()->getEntityName();
  479.             $primaryKeys[$entity][] = $command->getPrimaryKey();
  480.             $definitions[$entity] = $command->getDefinition();
  481.         }
  483.         if (empty($primaryKeys)) {
  484.             return;
  485.         }
  487.         $states = [];
  488.         foreach ($primaryKeys as $entity => $ids) {
  489.             $query = $this->connection->createQueryBuilder();
  491.             $definition = $definitions[$entity];
  493.             $query->addSelect('*');
  494.             $query->from(EntityDefinitionQueryHelper::escape($definition->getEntityName()));
  496.             $this->addPrimaryCondition($query, $ids);
  498.             $states[$entity] = $query->executeQuery()->fetchAllAssociative();
  499.         }
  501.         foreach ($commands as $command) {
  502.             if (!$command instanceof ChangeSetAware || !$command instanceof WriteCommand) {
  503.                 continue;
  504.             }
  506.             if (!$command->requiresChangeSet()) {
  507.                 continue;
  508.             }
  510.             $entity = $command->getDefinition()->getEntityName();
  512.             $command->setChangeSet(
  513.                 $this->calculateChangeSet($command, $states[$entity])
  514.             );
  515.         }
  516.     }
  518.     /**
  519.      * @param list<array<string, string>> $primaryKeys
  520.      */
  521.     private function addPrimaryCondition(DbalQueryBuilderAlias $query, array $primaryKeys): void
  522.     {
  523.         $all = [];
  524.         $i = 0;
  525.         foreach ($primaryKeys as $primaryKey) {
  526.             $where = [];
  528.             foreach ($primaryKey as $field => $value) {
  529.                 ++$i;
  530.                 $field = EntityDefinitionQueryHelper::escape($field);
  531.                 $where[] = $field . ' = :param' . $i;
  532.                 $query->setParameter('param' . $i, $value);
  533.             }
  535.             $all[] = implode(' AND ', $where);
  536.         }
  538.         $query->andWhere(implode(' OR ', $all));
  539.     }
  541.     /**
  542.      * @param list<array<string, mixed>> $states
  543.      */
  544.     private function calculateChangeSet(WriteCommand $command, array $states): ChangeSet
  545.     {
  546.         foreach ($states as $state) {
  547.             // check if current loop matches the command primary key
  548.             $primaryKey = array_intersect($command->getPrimaryKey(), $state);
  550.             if (\count(array_diff_assoc($command->getPrimaryKey(), $primaryKey)) === 0) {
  551.                 return new ChangeSet($state, $command->getPayload(), $command instanceof DeleteCommand);
  552.             }
  553.         }
  555.         return new ChangeSet([], [], $command instanceof DeleteCommand);
  556.     }
  558.     private function getPlaceholders(int $columnCount, int $tupleCount): string
  559.     {
  560.         if ($columnCount > 1) {
  561.             // multi column pk. Example: (product_id, language_id) IN ((p1, l1), (p2, l2), (px,lx),...)
  562.             $tupleStr = '(?' . str_repeat(',?', $columnCount - 1) . ')';
  563.         } else {
  564.             // single column pk. Example: category_id IN (c1, c2, c3,...)
  565.             $tupleStr = '?';
  566.         }
  568.         return $tupleStr . str_repeat(',' . $tupleStr, $tupleCount - 1);
  569.     }
  571.     private function getParentField(EntityDefinition $definition): ?FkField
  572.     {
  573.         if (!$definition->isInheritanceAware()) {
  574.             return null;
  575.         }
  577.         /** @var ManyToOneAssociationField|null $parent */
  578.         $parent = $definition->getFields()->get('parent');
  580.         if (!$parent) {
  581.             throw new ParentFieldNotFoundException($definition);
  582.         }
  584.         if (!$parent instanceof ManyToOneAssociationField) {
  585.             throw new InvalidParentAssociationException($definition, $parent);
  586.         }
  588.         $fk = $definition->getFields()->getByStorageName($parent->getStorageName());
  590.         if (!$fk) {
  591.             throw new CanNotFindParentStorageFieldException($definition);
  592.         }
  593.         if (!$fk instanceof FkField) {
  594.             throw new ParentFieldForeignKeyConstraintMissingException($definition, $fk);
  595.         }
  597.         return $fk;
  598.     }
  600.     /**
  601.      * @param array<string, string> $primaryKey
  602.      *
  603.      * @return array<string, mixed>
  604.      */
  605.     private function getCurrentState(EntityDefinition $definition, array $primaryKey, WriteCommandQueue $commandQueue): array
  606.     {
  607.         $commands = $commandQueue->getCommandsForEntity($definition, $primaryKey);
  609.         $useDatabase = true;
  611.         $state = [];
  613.         foreach ($commands as $command) {
  614.             if ($command instanceof DeleteCommand) {
  615.                 $state = [];
  616.                 $useDatabase = false;
  618.                 continue;
  619.             }
  621.             if (!$command instanceof InsertCommand && !$command instanceof UpdateCommand) {
  622.                 continue;
  623.             }
  625.             $state = array_replace_recursive($state, $command->getPayload());
  627.             if ($command instanceof InsertCommand) {
  628.                 $useDatabase = false;
  629.             }
  630.         }
  632.         if (!$useDatabase) {
  633.             return $state;
  634.         }
  636.         $hexPrimaryKey = Uuid::fromBytesToHexList($primaryKey);
  638.         $currentState = $this->primaryKeyBag === null ? null : $this->primaryKeyBag->getExistenceState($definition, $hexPrimaryKey);
  639.         if ($currentState === null) {
  640.             $currentState = $this->fetchFromDatabase($definition, $primaryKey);
  641.         }
  643.         $parent = $this->getParentField($definition);
  645.         if ($parent && \array_key_exists('parent', $currentState)) {
  646.             $currentState[$parent->getStorageName()] = $currentState['parent'];
  647.             unset($currentState['parent']);
  648.         }
  650.         return array_replace_recursive($currentState, $state);
  651.     }
  653.     /**
  654.      * @param array<string, string> $primaryKey
  655.      *
  656.      * @return array<string, mixed>
  657.      */
  658.     private function fetchFromDatabase(EntityDefinition $definition, array $primaryKey): array
  659.     {
  660.         $query = $this->connection->createQueryBuilder();
  661.         $query->from(EntityDefinitionQueryHelper::escape($definition->getEntityName()));
  663.         $fields = $definition->getPrimaryKeys();
  665.         /** @var Field&StorageAware $field */
  666.         foreach ($fields as $field) {
  667.             if (!\array_key_exists($field->getStorageName(), $primaryKey)) {
  668.                 if (!\array_key_exists($field->getPropertyName(), $primaryKey)) {
  669.                     throw new PrimaryKeyNotProvidedException($definition, $field);
  670.                 }
  672.                 $primaryKey[$field->getStorageName()] = $primaryKey[$field->getPropertyName()];
  673.                 unset($primaryKey[$field->getPropertyName()]);
  674.             }
  676.             $param = 'param_' . Uuid::randomHex();
  677.             $query->andWhere(EntityDefinitionQueryHelper::escape($field->getStorageName()) . ' = :' . $param);
  678.             $query->setParameter($param, $primaryKey[$field->getStorageName()]);
  679.         }
  681.         $query->addSelect('1 as `exists`');
  683.         if ($definition->isChildrenAware()) {
  684.             $query->addSelect('parent_id');
  685.         } elseif ($definition->isInheritanceAware()) {
  686.             $parent = $this->getParentField($definition);
  688.             if ($parent !== null) {
  689.                 $query->addSelect(
  690.                     EntityDefinitionQueryHelper::escape($parent->getStorageName())
  691.                     . ' as `parent`'
  692.                 );
  693.             }
  694.         }
  696.         $exists = $query->executeQuery()->fetchAssociative();
  697.         if (!$exists) {
  698.             $exists = [];
  699.         }
  701.         return $exists;
  702.     }
  704.     /**
  705.      * @param array<string, mixed> $data
  706.      * @param array<string, mixed> $state
  707.      * @param array<string, string> $primaryKey
  708.      */
  709.     private function isChild(EntityDefinition $definition, array $data, array $state, array $primaryKey, WriteCommandQueue $commandQueue): bool
  710.     {
  711.         if ($definition instanceof EntityTranslationDefinition) {
  712.             return $this->isTranslationChild($definition, $primaryKey, $commandQueue);
  713.         }
  715.         if (!$definition->isInheritanceAware()) {
  716.             return false;
  717.         }
  719.         /** @var Field&StorageAware $fk */
  720.         $fk = $this->getParentField($definition);
  721.         //foreign key provided, !== null has parent otherwise not
  722.         if (\array_key_exists($fk->getPropertyName(), $data)) {
  723.             return isset($data[$fk->getPropertyName()]);
  724.         }
  726.         /** @var Field $association */
  727.         $association = $definition->getFields()->get('parent');
  728.         if (isset($data[$association->getPropertyName()])) {
  729.             return true;
  730.         }
  732.         return isset($state[$fk->getStorageName()]);
  733.     }
  735.     /**
  736.      * @param array<string, mixed> $state
  737.      */
  738.     private function wasChild(EntityDefinition $definition, array $state): bool
  739.     {
  740.         if (!$definition->isInheritanceAware()) {
  741.             return false;
  742.         }
  744.         $fk = $this->getParentField($definition);
  746.         return $fk !== null && isset($state[$fk->getStorageName()]);
  747.     }
  749.     /**
  750.      * @param array<string, string> $primaryKey
  751.      */
  752.     private function isTranslationChild(EntityTranslationDefinition $definition, array $primaryKey, WriteCommandQueue $commandQueue): bool
  753.     {
  754.         $parent = $definition->getParentDefinition();
  756.         if (!$parent->isInheritanceAware()) {
  757.             return false;
  758.         }
  760.         /** @var FkField $fkField */
  761.         $fkField = $definition->getFields()->getByStorageName(
  762.             $parent->getEntityName() . '_id'
  763.         );
  764.         $parentPrimaryKey = [
  765.             'id' => $primaryKey[$fkField->getStorageName()],
  766.         ];
  768.         if ($parent->isVersionAware()) {
  769.             $parentPrimaryKey['versionId'] = $primaryKey[$parent->getEntityName() . '_version_id'];
  770.         }
  772.         $existence = $this->getExistence($parent, $parentPrimaryKey, [], $commandQueue);
  774.         return $existence->isChild();
  775.     }
  776. }