vendor/doctrine/orm/src/Persisters/Entity/BasicEntityPersister.php line 923

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Persisters\Entity;
  7. use BackedEnum;
  8. use Doctrine\Common\Collections\Criteria;
  9. use Doctrine\Common\Collections\Expr\Comparison;
  10. use Doctrine\Common\Collections\Order;
  11. use Doctrine\DBAL\ArrayParameterType;
  12. use Doctrine\DBAL\Connection;
  13. use Doctrine\DBAL\LockMode;
  14. use Doctrine\DBAL\ParameterType;
  15. use Doctrine\DBAL\Platforms\AbstractPlatform;
  16. use Doctrine\DBAL\Result;
  17. use Doctrine\DBAL\Types\Type;
  18. use Doctrine\DBAL\Types\Types;
  19. use Doctrine\ORM\EntityManagerInterface;
  20. use Doctrine\ORM\Mapping\AssociationMapping;
  21. use Doctrine\ORM\Mapping\ClassMetadata;
  22. use Doctrine\ORM\Mapping\JoinColumnMapping;
  23. use Doctrine\ORM\Mapping\ManyToManyAssociationMapping;
  24. use Doctrine\ORM\Mapping\MappingException;
  25. use Doctrine\ORM\Mapping\OneToManyAssociationMapping;
  26. use Doctrine\ORM\Mapping\QuoteStrategy;
  27. use Doctrine\ORM\OptimisticLockException;
  28. use Doctrine\ORM\PersistentCollection;
  29. use Doctrine\ORM\Persisters\Exception\CantUseInOperatorOnCompositeKeys;
  30. use Doctrine\ORM\Persisters\Exception\InvalidOrientation;
  31. use Doctrine\ORM\Persisters\Exception\UnrecognizedField;
  32. use Doctrine\ORM\Persisters\SqlExpressionVisitor;
  33. use Doctrine\ORM\Persisters\SqlValueVisitor;
  34. use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
  35. use Doctrine\ORM\Query;
  36. use Doctrine\ORM\Query\QueryException;
  37. use Doctrine\ORM\Query\ResultSetMapping;
  38. use Doctrine\ORM\Repository\Exception\InvalidFindByCall;
  39. use Doctrine\ORM\UnitOfWork;
  40. use Doctrine\ORM\Utility\IdentifierFlattener;
  41. use Doctrine\ORM\Utility\LockSqlHelper;
  42. use Doctrine\ORM\Utility\PersisterHelper;
  43. use LengthException;
  45. use function array_combine;
  46. use function array_keys;
  47. use function array_map;
  48. use function array_merge;
  49. use function array_search;
  50. use function array_unique;
  51. use function array_values;
  52. use function assert;
  53. use function count;
  54. use function implode;
  55. use function is_array;
  56. use function is_object;
  57. use function reset;
  58. use function spl_object_id;
  59. use function sprintf;
  60. use function str_contains;
  61. use function strtoupper;
  62. use function trim;
  64. /**
  65.  * A BasicEntityPersister maps an entity to a single table in a relational database.
  66.  *
  67.  * A persister is always responsible for a single entity type.
  68.  *
  69.  * EntityPersisters are used during a UnitOfWork to apply any changes to the persistent
  70.  * state of entities onto a relational database when the UnitOfWork is committed,
  71.  * as well as for basic querying of entities and their associations (not DQL).
  72.  *
  73.  * The persisting operations that are invoked during a commit of a UnitOfWork to
  74.  * persist the persistent entity state are:
  75.  *
  76.  *   - {@link addInsert} : To schedule an entity for insertion.
  77.  *   - {@link executeInserts} : To execute all scheduled insertions.
  78.  *   - {@link update} : To update the persistent state of an entity.
  79.  *   - {@link delete} : To delete the persistent state of an entity.
  80.  *
  81.  * As can be seen from the above list, insertions are batched and executed all at once
  82.  * for increased efficiency.
  83.  *
  84.  * The querying operations invoked during a UnitOfWork, either through direct find
  85.  * requests or lazy-loading, are the following:
  86.  *
  87.  *   - {@link load} : Loads (the state of) a single, managed entity.
  88.  *   - {@link loadAll} : Loads multiple, managed entities.
  89.  *   - {@link loadOneToOneEntity} : Loads a one/many-to-one entity association (lazy-loading).
  90.  *   - {@link loadOneToManyCollection} : Loads a one-to-many entity association (lazy-loading).
  91.  *   - {@link loadManyToManyCollection} : Loads a many-to-many entity association (lazy-loading).
  92.  *
  93.  * The BasicEntityPersister implementation provides the default behavior for
  94.  * persisting and querying entities that are mapped to a single database table.
  95.  *
  96.  * Subclasses can be created to provide custom persisting and querying strategies,
  97.  * i.e. spanning multiple tables.
  98.  */
  99. class BasicEntityPersister implements EntityPersister
  100. {
  101.     use LockSqlHelper;
  103.     /** @var array<string,string> */
  104.     private static array $comparisonMap = [
  105.         Comparison::EQ          => '= %s',
  106.         Comparison::NEQ         => '!= %s',
  107.         Comparison::GT          => '> %s',
  108.         Comparison::GTE         => '>= %s',
  109.         Comparison::LT          => '< %s',
  110.         Comparison::LTE         => '<= %s',
  111.         Comparison::IN          => 'IN (%s)',
  112.         Comparison::NIN         => 'NOT IN (%s)',
  113.         Comparison::CONTAINS    => 'LIKE %s',
  114.         Comparison::STARTS_WITH => 'LIKE %s',
  115.         Comparison::ENDS_WITH   => 'LIKE %s',
  116.     ];
  118.     /**
  119.      * The underlying DBAL Connection of the used EntityManager.
  120.      */
  121.     protected Connection $conn;
  123.     /**
  124.      * The database platform.
  125.      */
  126.     protected AbstractPlatform $platform;
  128.     /**
  129.      * Queued inserts.
  130.      *
  131.      * @psalm-var array<int, object>
  132.      */
  133.     protected array $queuedInserts = [];
  135.     /**
  136.      * The map of column names to DBAL mapping types of all prepared columns used
  137.      * when INSERTing or UPDATEing an entity.
  138.      *
  139.      * @see prepareInsertData($entity)
  140.      * @see prepareUpdateData($entity)
  141.      *
  142.      * @var mixed[]
  143.      */
  144.     protected array $columnTypes = [];
  146.     /**
  147.      * The map of quoted column names.
  148.      *
  149.      * @see prepareInsertData($entity)
  150.      * @see prepareUpdateData($entity)
  151.      *
  152.      * @var mixed[]
  153.      */
  154.     protected array $quotedColumns = [];
  156.     /**
  157.      * The INSERT SQL statement used for entities handled by this persister.
  158.      * This SQL is only generated once per request, if at all.
  159.      */
  160.     private string|null $insertSql = null;
  162.     /**
  163.      * The quote strategy.
  164.      */
  165.     protected QuoteStrategy $quoteStrategy;
  167.     /**
  168.      * The IdentifierFlattener used for manipulating identifiers
  169.      */
  170.     protected readonly IdentifierFlattener $identifierFlattener;
  172.     protected CachedPersisterContext $currentPersisterContext;
  173.     private readonly CachedPersisterContext $limitsHandlingContext;
  174.     private readonly CachedPersisterContext $noLimitsContext;
  176.     /**
  177.      * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
  178.      * and persists instances of the class described by the given ClassMetadata descriptor.
  179.      *
  180.      * @param ClassMetadata $class Metadata object that describes the mapping of the mapped entity class.
  181.      */
  182.     public function __construct(
  183.         protected EntityManagerInterface $em,
  184.         protected ClassMetadata $class,
  185.     ) {
  186.         $this->conn                  = $em->getConnection();
  187.         $this->platform              = $this->conn->getDatabasePlatform();
  188.         $this->quoteStrategy         = $em->getConfiguration()->getQuoteStrategy();
  189.         $this->identifierFlattener   = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
  190.         $this->noLimitsContext       = $this->currentPersisterContext = new CachedPersisterContext(
  191.             $class,
  192.             new Query\ResultSetMapping(),
  193.             false,
  194.         );
  195.         $this->limitsHandlingContext = new CachedPersisterContext(
  196.             $class,
  197.             new Query\ResultSetMapping(),
  198.             true,
  199.         );
  200.     }
  202.     public function getClassMetadata(): ClassMetadata
  203.     {
  204.         return $this->class;
  205.     }
  207.     public function getResultSetMapping(): ResultSetMapping
  208.     {
  209.         return $this->currentPersisterContext->rsm;
  210.     }
  212.     public function addInsert(object $entity): void
  213.     {
  214.         $this->queuedInserts[spl_object_id($entity)] = $entity;
  215.     }
  217.     /**
  218.      * {@inheritDoc}
  219.      */
  220.     public function getInserts(): array
  221.     {
  222.         return $this->queuedInserts;
  223.     }
  225.     public function executeInserts(): void
  226.     {
  227.         if (! $this->queuedInserts) {
  228.             return;
  229.         }
  231.         $uow            = $this->em->getUnitOfWork();
  232.         $idGenerator    = $this->class->idGenerator;
  233.         $isPostInsertId = $idGenerator->isPostInsertGenerator();
  235.         $stmt      = $this->conn->prepare($this->getInsertSQL());
  236.         $tableName = $this->class->getTableName();
  238.         foreach ($this->queuedInserts as $key => $entity) {
  239.             $insertData = $this->prepareInsertData($entity);
  241.             if (isset($insertData[$tableName])) {
  242.                 $paramIndex = 1;
  244.                 foreach ($insertData[$tableName] as $column => $value) {
  245.                     $stmt->bindValue($paramIndex++, $value, $this->columnTypes[$column]);
  246.                 }
  247.             }
  249.             $stmt->executeStatement();
  251.             if ($isPostInsertId) {
  252.                 $generatedId = $idGenerator->generateId($this->em, $entity);
  253.                 $id          = [$this->class->identifier[0] => $generatedId];
  255.                 $uow->assignPostInsertId($entity, $generatedId);
  256.             } else {
  257.                 $id = $this->class->getIdentifierValues($entity);
  258.             }
  260.             if ($this->class->requiresFetchAfterChange) {
  261.                 $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  262.             }
  264.             // Unset this queued insert, so that the prepareUpdateData() method knows right away
  265.             // (for the next entity already) that the current entity has been written to the database
  266.             // and no extra updates need to be scheduled to refer to it.
  267.             //
  268.             // In \Doctrine\ORM\UnitOfWork::executeInserts(), the UoW already removed entities
  269.             // from its own list (\Doctrine\ORM\UnitOfWork::$entityInsertions) right after they
  270.             // were given to our addInsert() method.
  271.             unset($this->queuedInserts[$key]);
  272.         }
  273.     }
  275.     /**
  276.      * Retrieves the default version value which was created
  277.      * by the preceding INSERT statement and assigns it back in to the
  278.      * entities version field if the given entity is versioned.
  279.      * Also retrieves values of columns marked as 'non insertable' and / or
  280.      * 'not updatable' and assigns them back to the entities corresponding fields.
  281.      *
  282.      * @param mixed[] $id
  283.      */
  284.     protected function assignDefaultVersionAndUpsertableValues(object $entity, array $id): void
  285.     {
  286.         $values = $this->fetchVersionAndNotUpsertableValues($this->class, $id);
  288.         foreach ($values as $field => $value) {
  289.             $value = Type::getType($this->class->fieldMappings[$field]->type)->convertToPHPValue($value, $this->platform);
  291.             $this->class->setFieldValue($entity, $field, $value);
  292.         }
  293.     }
  295.     /**
  296.      * Fetches the current version value of a versioned entity and / or the values of fields
  297.      * marked as 'not insertable' and / or 'not updatable'.
  298.      *
  299.      * @param mixed[] $id
  300.      */
  301.     protected function fetchVersionAndNotUpsertableValues(ClassMetadata $versionedClass, array $id): mixed
  302.     {
  303.         $columnNames = [];
  304.         foreach ($this->class->fieldMappings as $key => $column) {
  305.             if (isset($column->generated) || ($this->class->isVersioned && $key === $versionedClass->versionField)) {
  306.                 $columnNames[$key] = $this->quoteStrategy->getColumnName($key, $versionedClass, $this->platform);
  307.             }
  308.         }
  310.         $tableName  = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
  311.         $identifier = $this->quoteStrategy->getIdentifierColumnNames($versionedClass, $this->platform);
  313.         // FIXME: Order with composite keys might not be correct
  314.         $sql = 'SELECT ' . implode(', ', $columnNames)
  315.             . ' FROM ' . $tableName
  316.             . ' WHERE ' . implode(' = ? AND ', $identifier) . ' = ?';
  318.         $flatId = $this->identifierFlattener->flattenIdentifier($versionedClass, $id);
  320.         $values = $this->conn->fetchNumeric(
  321.             $sql,
  322.             array_values($flatId),
  323.             $this->extractIdentifierTypes($id, $versionedClass),
  324.         );
  326.         if ($values === false) {
  327.             throw new LengthException('Unexpected empty result for database query.');
  328.         }
  330.         $values = array_combine(array_keys($columnNames), $values);
  332.         if (! $values) {
  333.             throw new LengthException('Unexpected number of database columns.');
  334.         }
  336.         return $values;
  337.     }
  339.     /**
  340.      * @param mixed[] $id
  341.      *
  342.      * @return list<ParameterType|int|string>
  343.      * @psalm-return list<ParameterType::*|ArrayParameterType::*|string>
  344.      */
  345.     final protected function extractIdentifierTypes(array $id, ClassMetadata $versionedClass): array
  346.     {
  347.         $types = [];
  349.         foreach ($id as $field => $value) {
  350.             $types = [...$types, ...$this->getTypes($field, $value, $versionedClass)];
  351.         }
  353.         return $types;
  354.     }
  356.     public function update(object $entity): void
  357.     {
  358.         $tableName  = $this->class->getTableName();
  359.         $updateData = $this->prepareUpdateData($entity);
  361.         if (! isset($updateData[$tableName])) {
  362.             return;
  363.         }
  365.         $data = $updateData[$tableName];
  367.         if (! $data) {
  368.             return;
  369.         }
  371.         $isVersioned     = $this->class->isVersioned;
  372.         $quotedTableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  374.         $this->updateTable($entity, $quotedTableName, $data, $isVersioned);
  376.         if ($this->class->requiresFetchAfterChange) {
  377.             $id = $this->class->getIdentifierValues($entity);
  379.             $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  380.         }
  381.     }
  383.     /**
  384.      * Performs an UPDATE statement for an entity on a specific table.
  385.      * The UPDATE can optionally be versioned, which requires the entity to have a version field.
  386.      *
  387.      * @param object  $entity          The entity object being updated.
  388.      * @param string  $quotedTableName The quoted name of the table to apply the UPDATE on.
  389.      * @param mixed[] $updateData      The map of columns to update (column => value).
  390.      * @param bool    $versioned       Whether the UPDATE should be versioned.
  391.      *
  392.      * @throws UnrecognizedField
  393.      * @throws OptimisticLockException
  394.      */
  395.     final protected function updateTable(
  396.         object $entity,
  397.         string $quotedTableName,
  398.         array $updateData,
  399.         bool $versioned = false,
  400.     ): void {
  401.         $set    = [];
  402.         $types  = [];
  403.         $params = [];
  405.         foreach ($updateData as $columnName => $value) {
  406.             $placeholder = '?';
  407.             $column      = $columnName;
  409.             switch (true) {
  410.                 case isset($this->class->fieldNames[$columnName]):
  411.                     $fieldName = $this->class->fieldNames[$columnName];
  412.                     $column    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  414.                     if (isset($this->class->fieldMappings[$fieldName])) {
  415.                         $type        = Type::getType($this->columnTypes[$columnName]);
  416.                         $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  417.                     }
  419.                     break;
  421.                 case isset($this->quotedColumns[$columnName]):
  422.                     $column = $this->quotedColumns[$columnName];
  424.                     break;
  425.             }
  427.             $params[] = $value;
  428.             $set[]    = $column . ' = ' . $placeholder;
  429.             $types[]  = $this->columnTypes[$columnName];
  430.         }
  432.         $where      = [];
  433.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  435.         foreach ($this->class->identifier as $idField) {
  436.             if (! isset($this->class->associationMappings[$idField])) {
  437.                 $params[] = $identifier[$idField];
  438.                 $types[]  = $this->class->fieldMappings[$idField]->type;
  439.                 $where[]  = $this->quoteStrategy->getColumnName($idField, $this->class, $this->platform);
  441.                 continue;
  442.             }
  444.             assert($this->class->associationMappings[$idField]->isToOneOwningSide());
  446.             $params[] = $identifier[$idField];
  447.             $where[]  = $this->quoteStrategy->getJoinColumnName(
  448.                 $this->class->associationMappings[$idField]->joinColumns[0],
  449.                 $this->class,
  450.                 $this->platform,
  451.             );
  453.             $targetMapping = $this->em->getClassMetadata($this->class->associationMappings[$idField]->targetEntity);
  454.             $targetType    = PersisterHelper::getTypeOfField($targetMapping->identifier[0], $targetMapping, $this->em);
  456.             if ($targetType === []) {
  457.                 throw UnrecognizedField::byFullyQualifiedName($this->class->name, $targetMapping->identifier[0]);
  458.             }
  460.             $types[] = reset($targetType);
  461.         }
  463.         if ($versioned) {
  464.             $versionField = $this->class->versionField;
  465.             assert($versionField !== null);
  466.             $versionFieldType = $this->class->fieldMappings[$versionField]->type;
  467.             $versionColumn    = $this->quoteStrategy->getColumnName($versionField, $this->class, $this->platform);
  469.             $where[]  = $versionColumn;
  470.             $types[]  = $this->class->fieldMappings[$versionField]->type;
  471.             $params[] = $this->class->reflFields[$versionField]->getValue($entity);
  473.             switch ($versionFieldType) {
  474.                 case Types::SMALLINT:
  475.                 case Types::INTEGER:
  476.                 case Types::BIGINT:
  477.                     $set[] = $versionColumn . ' = ' . $versionColumn . ' + 1';
  478.                     break;
  480.                 case Types::DATETIME_MUTABLE:
  481.                     $set[] = $versionColumn . ' = CURRENT_TIMESTAMP';
  482.                     break;
  483.             }
  484.         }
  486.         $sql = 'UPDATE ' . $quotedTableName
  487.              . ' SET ' . implode(', ', $set)
  488.              . ' WHERE ' . implode(' = ? AND ', $where) . ' = ?';
  490.         $result = $this->conn->executeStatement($sql, $params, $types);
  492.         if ($versioned && ! $result) {
  493.             throw OptimisticLockException::lockFailed($entity);
  494.         }
  495.     }
  497.     /**
  498.      * @param array<mixed> $identifier
  499.      * @param string[]     $types
  500.      *
  501.      * @todo Add check for platform if it supports foreign keys/cascading.
  502.      */
  503.     protected function deleteJoinTableRecords(array $identifier, array $types): void
  504.     {
  505.         foreach ($this->class->associationMappings as $mapping) {
  506.             if (! $mapping->isManyToMany() || $mapping->isOnDeleteCascade) {
  507.                 continue;
  508.             }
  510.             // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
  511.             // like self-referential relationship between different levels of an inheritance hierarchy? I hope not!
  512.             $selfReferential = ($mapping->targetEntity === $mapping->sourceEntity);
  513.             $class           = $this->class;
  514.             $association     = $mapping;
  515.             $otherColumns    = [];
  516.             $otherKeys       = [];
  517.             $keys            = [];
  519.             if (! $mapping->isOwningSide()) {
  520.                 $class = $this->em->getClassMetadata($mapping->targetEntity);
  521.             }
  523.             $association = $this->em->getMetadataFactory()->getOwningSide($association);
  524.             $joinColumns = $mapping->isOwningSide()
  525.                 ? $association->joinTable->joinColumns
  526.                 : $association->joinTable->inverseJoinColumns;
  528.             if ($selfReferential) {
  529.                 $otherColumns = ! $mapping->isOwningSide()
  530.                     ? $association->joinTable->joinColumns
  531.                     : $association->joinTable->inverseJoinColumns;
  532.             }
  534.             foreach ($joinColumns as $joinColumn) {
  535.                 $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  536.             }
  538.             foreach ($otherColumns as $joinColumn) {
  539.                 $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  540.             }
  542.             $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  544.             $this->conn->delete($joinTableName, array_combine($keys, $identifier), $types);
  546.             if ($selfReferential) {
  547.                 $this->conn->delete($joinTableName, array_combine($otherKeys, $identifier), $types);
  548.             }
  549.         }
  550.     }
  552.     public function delete(object $entity): bool
  553.     {
  554.         $class      = $this->class;
  555.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  556.         $tableName  = $this->quoteStrategy->getTableName($class, $this->platform);
  557.         $idColumns  = $this->quoteStrategy->getIdentifierColumnNames($class, $this->platform);
  558.         $id         = array_combine($idColumns, $identifier);
  559.         $types      = $this->getClassIdentifiersTypes($class);
  561.         $this->deleteJoinTableRecords($identifier, $types);
  563.         return (bool) $this->conn->delete($tableName, $id, $types);
  564.     }
  566.     /**
  567.      * Prepares the changeset of an entity for database insertion (UPDATE).
  568.      *
  569.      * The changeset is obtained from the currently running UnitOfWork.
  570.      *
  571.      * During this preparation the array that is passed as the second parameter is filled with
  572.      * <columnName> => <value> pairs, grouped by table name.
  573.      *
  574.      * Example:
  575.      * <code>
  576.      * array(
  577.      *    'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...),
  578.      *    'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...),
  579.      *    ...
  580.      * )
  581.      * </code>
  582.      *
  583.      * @param object $entity   The entity for which to prepare the data.
  584.      * @param bool   $isInsert Whether the data to be prepared refers to an insert statement.
  585.      *
  586.      * @return mixed[][] The prepared data.
  587.      * @psalm-return array<string, array<array-key, mixed|null>>
  588.      */
  589.     protected function prepareUpdateData(object $entity, bool $isInsert = false): array
  590.     {
  591.         $versionField = null;
  592.         $result       = [];
  593.         $uow          = $this->em->getUnitOfWork();
  595.         $versioned = $this->class->isVersioned;
  596.         if ($versioned !== false) {
  597.             $versionField = $this->class->versionField;
  598.         }
  600.         foreach ($uow->getEntityChangeSet($entity) as $field => $change) {
  601.             if (isset($versionField) && $versionField === $field) {
  602.                 continue;
  603.             }
  605.             if (isset($this->class->embeddedClasses[$field])) {
  606.                 continue;
  607.             }
  609.             $newVal = $change[1];
  611.             if (! isset($this->class->associationMappings[$field])) {
  612.                 $fieldMapping = $this->class->fieldMappings[$field];
  613.                 $columnName   = $fieldMapping->columnName;
  615.                 if (! $isInsert && isset($fieldMapping->notUpdatable)) {
  616.                     continue;
  617.                 }
  619.                 if ($isInsert && isset($fieldMapping->notInsertable)) {
  620.                     continue;
  621.                 }
  623.                 $this->columnTypes[$columnName] = $fieldMapping->type;
  625.                 $result[$this->getOwningTable($field)][$columnName] = $newVal;
  627.                 continue;
  628.             }
  630.             $assoc = $this->class->associationMappings[$field];
  632.             // Only owning side of x-1 associations can have a FK column.
  633.             if (! $assoc->isToOneOwningSide()) {
  634.                 continue;
  635.             }
  637.             if ($newVal !== null) {
  638.                 $oid = spl_object_id($newVal);
  640.                 // If the associated entity $newVal is not yet persisted and/or does not yet have
  641.                 // an ID assigned, we must set $newVal = null. This will insert a null value and
  642.                 // schedule an extra update on the UnitOfWork.
  643.                 //
  644.                 // This gives us extra time to a) possibly obtain a database-generated identifier
  645.                 // value for $newVal, and b) insert $newVal into the database before the foreign
  646.                 // key reference is being made.
  647.                 //
  648.                 // When looking at $this->queuedInserts and $uow->isScheduledForInsert, be aware
  649.                 // of the implementation details that our own executeInserts() method will remove
  650.                 // entities from the former as soon as the insert statement has been executed and
  651.                 // a post-insert ID has been assigned (if necessary), and that the UnitOfWork has
  652.                 // already removed entities from its own list at the time they were passed to our
  653.                 // addInsert() method.
  654.                 //
  655.                 // Then, there is one extra exception we can make: An entity that references back to itself
  656.                 // _and_ uses an application-provided ID (the "NONE" generator strategy) also does not
  657.                 // need the extra update, although it is still in the list of insertions itself.
  658.                 // This looks like a minor optimization at first, but is the capstone for being able to
  659.                 // use non-NULLable, self-referencing associations in applications that provide IDs (like UUIDs).
  660.                 if (
  661.                     (isset($this->queuedInserts[$oid]) || $uow->isScheduledForInsert($newVal))
  662.                     && ! ($newVal === $entity && $this->class->isIdentifierNatural())
  663.                 ) {
  664.                     $uow->scheduleExtraUpdate($entity, [$field => [null, $newVal]]);
  666.                     $newVal = null;
  667.                 }
  668.             }
  670.             $newValId = null;
  672.             if ($newVal !== null) {
  673.                 $newValId = $uow->getEntityIdentifier($newVal);
  674.             }
  676.             $targetClass = $this->em->getClassMetadata($assoc->targetEntity);
  677.             $owningTable = $this->getOwningTable($field);
  679.             foreach ($assoc->joinColumns as $joinColumn) {
  680.                 $sourceColumn = $joinColumn->name;
  681.                 $targetColumn = $joinColumn->referencedColumnName;
  682.                 $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  684.                 $this->quotedColumns[$sourceColumn]  = $quotedColumn;
  685.                 $this->columnTypes[$sourceColumn]    = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
  686.                 $result[$owningTable][$sourceColumn] = $newValId
  687.                     ? $newValId[$targetClass->getFieldForColumn($targetColumn)]
  688.                     : null;
  689.             }
  690.         }
  692.         return $result;
  693.     }
  695.     /**
  696.      * Prepares the data changeset of a managed entity for database insertion (initial INSERT).
  697.      * The changeset of the entity is obtained from the currently running UnitOfWork.
  698.      *
  699.      * The default insert data preparation is the same as for updates.
  700.      *
  701.      * @see prepareUpdateData
  702.      *
  703.      * @param object $entity The entity for which to prepare the data.
  704.      *
  705.      * @return mixed[][] The prepared data for the tables to update.
  706.      * @psalm-return array<string, mixed[]>
  707.      */
  708.     protected function prepareInsertData(object $entity): array
  709.     {
  710.         return $this->prepareUpdateData($entity, true);
  711.     }
  713.     public function getOwningTable(string $fieldName): string
  714.     {
  715.         return $this->class->getTableName();
  716.     }
  718.     /**
  719.      * {@inheritDoc}
  720.      */
  721.     public function load(
  722.         array $criteria,
  723.         object|null $entity = null,
  724.         AssociationMapping|null $assoc = null,
  725.         array $hints = [],
  726.         LockMode|int|null $lockMode = null,
  727.         int|null $limit = null,
  728.         array|null $orderBy = null,
  729.     ): object|null {
  730.         $this->switchPersisterContext(null, $limit);
  732.         $sql              = $this->getSelectSQL($criteria, $assoc, $lockMode, $limit, null, $orderBy);
  733.         [$params, $types] = $this->expandParameters($criteria);
  734.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  736.         if ($entity !== null) {
  737.             $hints[Query::HINT_REFRESH]        = true;
  738.             $hints[Query::HINT_REFRESH_ENTITY] = $entity;
  739.         }
  741.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  742.         $entities = $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, $hints);
  744.         return $entities ? $entities[0] : null;
  745.     }
  747.     /**
  748.      * {@inheritDoc}
  749.      */
  750.     public function loadById(array $identifier, object|null $entity = null): object|null
  751.     {
  752.         return $this->load($identifier, $entity);
  753.     }
  755.     /**
  756.      * {@inheritDoc}
  757.      */
  758.     public function loadOneToOneEntity(AssociationMapping $assoc, object $sourceEntity, array $identifier = []): object|null
  759.     {
  760.         $foundEntity = $this->em->getUnitOfWork()->tryGetById($identifier, $assoc->targetEntity);
  761.         if ($foundEntity !== false) {
  762.             return $foundEntity;
  763.         }
  765.         $targetClass = $this->em->getClassMetadata($assoc->targetEntity);
  767.         if ($assoc->isOwningSide()) {
  768.             $isInverseSingleValued = $assoc->inversedBy !== null && ! $targetClass->isCollectionValuedAssociation($assoc->inversedBy);
  770.             // Mark inverse side as fetched in the hints, otherwise the UoW would
  771.             // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
  772.             $hints = [];
  774.             if ($isInverseSingleValued) {
  775.                 $hints['fetched']['r'][$assoc->inversedBy] = true;
  776.             }
  778.             $targetEntity = $this->load($identifier, null, $assoc, $hints);
  780.             // Complete bidirectional association, if necessary
  781.             if ($targetEntity !== null && $isInverseSingleValued) {
  782.                 $targetClass->reflFields[$assoc->inversedBy]->setValue($targetEntity, $sourceEntity);
  783.             }
  785.             return $targetEntity;
  786.         }
  788.         assert(isset($assoc->mappedBy));
  789.         $sourceClass = $this->em->getClassMetadata($assoc->sourceEntity);
  790.         $owningAssoc = $targetClass->getAssociationMapping($assoc->mappedBy);
  791.         assert($owningAssoc->isOneToOneOwningSide());
  793.         $computedIdentifier = [];
  795.         /** @var array<string,mixed>|null $sourceEntityData */
  796.         $sourceEntityData = null;
  798.         // TRICKY: since the association is specular source and target are flipped
  799.         foreach ($owningAssoc->targetToSourceKeyColumns as $sourceKeyColumn => $targetKeyColumn) {
  800.             if (! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
  801.                 // The likely case here is that the column is a join column
  802.                 // in an association mapping. However, there is no guarantee
  803.                 // at this point that a corresponding (generally identifying)
  804.                 // association has been mapped in the source entity. To handle
  805.                 // this case we directly reference the column-keyed data used
  806.                 // to initialize the source entity before throwing an exception.
  807.                 $resolvedSourceData = false;
  808.                 if (! isset($sourceEntityData)) {
  809.                     $sourceEntityData = $this->em->getUnitOfWork()->getOriginalEntityData($sourceEntity);
  810.                 }
  812.                 if (isset($sourceEntityData[$sourceKeyColumn])) {
  813.                     $dataValue = $sourceEntityData[$sourceKeyColumn];
  814.                     if ($dataValue !== null) {
  815.                         $resolvedSourceData                                                    = true;
  816.                         $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  817.                             $dataValue;
  818.                     }
  819.                 }
  821.                 if (! $resolvedSourceData) {
  822.                     throw MappingException::joinColumnMustPointToMappedField(
  823.                         $sourceClass->name,
  824.                         $sourceKeyColumn,
  825.                     );
  826.                 }
  827.             } else {
  828.                 $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  829.                     $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
  830.             }
  831.         }
  833.         $targetEntity = $this->load($computedIdentifier, null, $assoc);
  835.         if ($targetEntity !== null) {
  836.             $targetClass->setFieldValue($targetEntity, $assoc->mappedBy, $sourceEntity);
  837.         }
  839.         return $targetEntity;
  840.     }
  842.     /**
  843.      * {@inheritDoc}
  844.      */
  845.     public function refresh(array $id, object $entity, LockMode|int|null $lockMode = null): void
  846.     {
  847.         $sql              = $this->getSelectSQL($id, null, $lockMode);
  848.         [$params, $types] = $this->expandParameters($id);
  849.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  851.         $hydrator = $this->em->newHydrator(Query::HYDRATE_OBJECT);
  852.         $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [Query::HINT_REFRESH => true]);
  853.     }
  855.     public function count(array|Criteria $criteria = []): int
  856.     {
  857.         $sql = $this->getCountSQL($criteria);
  859.         [$params, $types] = $criteria instanceof Criteria
  860.             ? $this->expandCriteriaParameters($criteria)
  861.             : $this->expandParameters($criteria);
  863.         return (int) $this->conn->executeQuery($sql, $params, $types)->fetchOne();
  864.     }
  866.     /**
  867.      * {@inheritDoc}
  868.      */
  869.     public function loadCriteria(Criteria $criteria): array
  870.     {
  871.         $orderBy = array_map(
  872.             static fn (Order $order): string => $order->value,
  873.             $criteria->orderings(),
  874.         );
  875.         $limit   = $criteria->getMaxResults();
  876.         $offset  = $criteria->getFirstResult();
  877.         $query   = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  879.         [$params, $types] = $this->expandCriteriaParameters($criteria);
  881.         $stmt     = $this->conn->executeQuery($query, $params, $types);
  882.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  884.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  885.     }
  887.     /**
  888.      * {@inheritDoc}
  889.      */
  890.     public function expandCriteriaParameters(Criteria $criteria): array
  891.     {
  892.         $expression = $criteria->getWhereExpression();
  893.         $sqlParams  = [];
  894.         $sqlTypes   = [];
  896.         if ($expression === null) {
  897.             return [$sqlParams, $sqlTypes];
  898.         }
  900.         $valueVisitor = new SqlValueVisitor();
  902.         $valueVisitor->dispatch($expression);
  904.         [, $types] = $valueVisitor->getParamsAndTypes();
  906.         foreach ($types as $type) {
  907.             [$field, $value, $operator] = $type;
  909.             if ($value === null && ($operator === Comparison::EQ || $operator === Comparison::NEQ)) {
  910.                 continue;
  911.             }
  913.             $sqlParams = [...$sqlParams, ...$this->getValues($value)];
  914.             $sqlTypes  = [...$sqlTypes, ...$this->getTypes($field, $value, $this->class)];
  915.         }
  917.         return [$sqlParams, $sqlTypes];
  918.     }
  920.     /**
  921.      * {@inheritDoc}
  922.      */
  923.     public function loadAll(
  924.         array $criteria = [],
  925.         array|null $orderBy = null,
  926.         int|null $limit = null,
  927.         int|null $offset = null,
  928.     ): array {
  929.         $this->switchPersisterContext($offset, $limit);
  931.         $sql              = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  932.         [$params, $types] = $this->expandParameters($criteria);
  933.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  935.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  937.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  938.     }
  940.     /**
  941.      * {@inheritDoc}
  942.      */
  943.     public function getManyToManyCollection(
  944.         AssociationMapping $assoc,
  945.         object $sourceEntity,
  946.         int|null $offset = null,
  947.         int|null $limit = null,
  948.     ): array {
  949.         assert($assoc->isManyToMany());
  950.         $this->switchPersisterContext($offset, $limit);
  952.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity, $offset, $limit);
  954.         return $this->loadArrayFromResult($assoc, $stmt);
  955.     }
  957.     /**
  958.      * Loads an array of entities from a given DBAL statement.
  959.      *
  960.      * @return mixed[]
  961.      */
  962.     private function loadArrayFromResult(AssociationMapping $assoc, Result $stmt): array
  963.     {
  964.         $rsm   = $this->currentPersisterContext->rsm;
  965.         $hints = [UnitOfWork::HINT_DEFEREAGERLOAD => true];
  967.         if ($assoc->isIndexed()) {
  968.             $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  969.             $rsm->addIndexBy('r', $assoc->indexBy());
  970.         }
  972.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  973.     }
  975.     /**
  976.      * Hydrates a collection from a given DBAL statement.
  977.      *
  978.      * @return mixed[]
  979.      */
  980.     private function loadCollectionFromStatement(
  981.         AssociationMapping $assoc,
  982.         Result $stmt,
  983.         PersistentCollection $coll,
  984.     ): array {
  985.         $rsm   = $this->currentPersisterContext->rsm;
  986.         $hints = [
  987.             UnitOfWork::HINT_DEFEREAGERLOAD => true,
  988.             'collection' => $coll,
  989.         ];
  991.         if ($assoc->isIndexed()) {
  992.             $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  993.             $rsm->addIndexBy('r', $assoc->indexBy());
  994.         }
  996.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  997.     }
  999.     /**
  1000.      * {@inheritDoc}
  1001.      */
  1002.     public function loadManyToManyCollection(AssociationMapping $assoc, object $sourceEntity, PersistentCollection $collection): array
  1003.     {
  1004.         assert($assoc->isManyToMany());
  1005.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity);
  1007.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1008.     }
  1010.     /** @throws MappingException */
  1011.     private function getManyToManyStatement(
  1012.         AssociationMapping&ManyToManyAssociationMapping $assoc,
  1013.         object $sourceEntity,
  1014.         int|null $offset = null,
  1015.         int|null $limit = null,
  1016.     ): Result {
  1017.         $this->switchPersisterContext($offset, $limit);
  1019.         $sourceClass = $this->em->getClassMetadata($assoc->sourceEntity);
  1020.         $class       = $sourceClass;
  1021.         $association = $assoc;
  1022.         $criteria    = [];
  1023.         $parameters  = [];
  1025.         if (! $assoc->isOwningSide()) {
  1026.             $class = $this->em->getClassMetadata($assoc->targetEntity);
  1027.         }
  1029.         $association = $this->em->getMetadataFactory()->getOwningSide($assoc);
  1030.         $joinColumns = $assoc->isOwningSide()
  1031.             ? $association->joinTable->joinColumns
  1032.             : $association->joinTable->inverseJoinColumns;
  1034.         $quotedJoinTable = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1036.         foreach ($joinColumns as $joinColumn) {
  1037.             $sourceKeyColumn = $joinColumn->referencedColumnName;
  1038.             $quotedKeyColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1040.             switch (true) {
  1041.                 case $sourceClass->containsForeignIdentifier:
  1042.                     $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1043.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1045.                     if (isset($sourceClass->associationMappings[$field])) {
  1046.                         $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1047.                         $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]->targetEntity)->identifier[0]];
  1048.                     }
  1050.                     break;
  1052.                 case isset($sourceClass->fieldNames[$sourceKeyColumn]):
  1053.                     $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1054.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1056.                     break;
  1058.                 default:
  1059.                     throw MappingException::joinColumnMustPointToMappedField(
  1060.                         $sourceClass->name,
  1061.                         $sourceKeyColumn,
  1062.                     );
  1063.             }
  1065.             $criteria[$quotedJoinTable . '.' . $quotedKeyColumn] = $value;
  1066.             $parameters[]                                        = [
  1067.                 'value' => $value,
  1068.                 'field' => $field,
  1069.                 'class' => $sourceClass,
  1070.             ];
  1071.         }
  1073.         $sql              = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1074.         [$params, $types] = $this->expandToManyParameters($parameters);
  1076.         return $this->conn->executeQuery($sql, $params, $types);
  1077.     }
  1079.     public function getSelectSQL(
  1080.         array|Criteria $criteria,
  1081.         AssociationMapping|null $assoc = null,
  1082.         LockMode|int|null $lockMode = null,
  1083.         int|null $limit = null,
  1084.         int|null $offset = null,
  1085.         array|null $orderBy = null,
  1086.     ): string {
  1087.         $this->switchPersisterContext($offset, $limit);
  1089.         $joinSql    = '';
  1090.         $orderBySql = '';
  1092.         if ($assoc !== null && $assoc->isManyToMany()) {
  1093.             $joinSql = $this->getSelectManyToManyJoinSQL($assoc);
  1094.         }
  1096.         if ($assoc !== null && $assoc->isOrdered()) {
  1097.             $orderBy = $assoc->orderBy();
  1098.         }
  1100.         if ($orderBy) {
  1101.             $orderBySql = $this->getOrderBySQL($orderBy, $this->getSQLTableAlias($this->class->name));
  1102.         }
  1104.         $conditionSql = $criteria instanceof Criteria
  1105.             ? $this->getSelectConditionCriteriaSQL($criteria)
  1106.             : $this->getSelectConditionSQL($criteria, $assoc);
  1108.         $lockSql = match ($lockMode) {
  1109.             LockMode::PESSIMISTIC_READ => ' ' . $this->getReadLockSQL($this->platform),
  1110.             LockMode::PESSIMISTIC_WRITE => ' ' . $this->getWriteLockSQL($this->platform),
  1111.             default => '',
  1112.         };
  1114.         $columnList = $this->getSelectColumnsSQL();
  1115.         $tableAlias = $this->getSQLTableAlias($this->class->name);
  1116.         $filterSql  = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1117.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1119.         if ($filterSql !== '') {
  1120.             $conditionSql = $conditionSql
  1121.                 ? $conditionSql . ' AND ' . $filterSql
  1122.                 : $filterSql;
  1123.         }
  1125.         $select = 'SELECT ' . $columnList;
  1126.         $from   = ' FROM ' . $tableName . ' ' . $tableAlias;
  1127.         $join   = $this->currentPersisterContext->selectJoinSql . $joinSql;
  1128.         $where  = ($conditionSql ? ' WHERE ' . $conditionSql : '');
  1129.         $lock   = $this->platform->appendLockHint($from, $lockMode ?? LockMode::NONE);
  1130.         $query  = $select
  1131.             . $lock
  1132.             . $join
  1133.             . $where
  1134.             . $orderBySql;
  1136.         return $this->platform->modifyLimitQuery($query, $limit, $offset ?? 0) . $lockSql;
  1137.     }
  1139.     public function getCountSQL(array|Criteria $criteria = []): string
  1140.     {
  1141.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1142.         $tableAlias = $this->getSQLTableAlias($this->class->name);
  1144.         $conditionSql = $criteria instanceof Criteria
  1145.             ? $this->getSelectConditionCriteriaSQL($criteria)
  1146.             : $this->getSelectConditionSQL($criteria);
  1148.         $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1150.         if ($filterSql !== '') {
  1151.             $conditionSql = $conditionSql
  1152.                 ? $conditionSql . ' AND ' . $filterSql
  1153.                 : $filterSql;
  1154.         }
  1156.         return 'SELECT COUNT(*) '
  1157.             . 'FROM ' . $tableName . ' ' . $tableAlias
  1158.             . (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
  1159.     }
  1161.     /**
  1162.      * Gets the ORDER BY SQL snippet for ordered collections.
  1163.      *
  1164.      * @psalm-param array<string, string> $orderBy
  1165.      *
  1166.      * @throws InvalidOrientation
  1167.      * @throws InvalidFindByCall
  1168.      * @throws UnrecognizedField
  1169.      */
  1170.     final protected function getOrderBySQL(array $orderBy, string $baseTableAlias): string
  1171.     {
  1172.         $orderByList = [];
  1174.         foreach ($orderBy as $fieldName => $orientation) {
  1175.             $orientation = strtoupper(trim($orientation));
  1177.             if ($orientation !== 'ASC' && $orientation !== 'DESC') {
  1178.                 throw InvalidOrientation::fromClassNameAndField($this->class->name, $fieldName);
  1179.             }
  1181.             if (isset($this->class->fieldMappings[$fieldName])) {
  1182.                 $tableAlias = isset($this->class->fieldMappings[$fieldName]->inherited)
  1183.                     ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]->inherited)
  1184.                     : $baseTableAlias;
  1186.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  1187.                 $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1189.                 continue;
  1190.             }
  1192.             if (isset($this->class->associationMappings[$fieldName])) {
  1193.                 $association = $this->class->associationMappings[$fieldName];
  1194.                 if (! $association->isOwningSide()) {
  1195.                     throw InvalidFindByCall::fromInverseSideUsage($this->class->name, $fieldName);
  1196.                 }
  1198.                 assert($association->isToOneOwningSide());
  1200.                 $tableAlias = isset($association->inherited)
  1201.                     ? $this->getSQLTableAlias($association->inherited)
  1202.                     : $baseTableAlias;
  1204.                 foreach ($association->joinColumns as $joinColumn) {
  1205.                     $columnName    = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1206.                     $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1207.                 }
  1209.                 continue;
  1210.             }
  1212.             throw UnrecognizedField::byFullyQualifiedName($this->class->name, $fieldName);
  1213.         }
  1215.         return ' ORDER BY ' . implode(', ', $orderByList);
  1216.     }
  1218.     /**
  1219.      * Gets the SQL fragment with the list of columns to select when querying for
  1220.      * an entity in this persister.
  1221.      *
  1222.      * Subclasses should override this method to alter or change the select column
  1223.      * list SQL fragment. Note that in the implementation of BasicEntityPersister
  1224.      * the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}.
  1225.      * Subclasses may or may not do the same.
  1226.      */
  1227.     protected function getSelectColumnsSQL(): string
  1228.     {
  1229.         if ($this->currentPersisterContext->selectColumnListSql !== null) {
  1230.             return $this->currentPersisterContext->selectColumnListSql;
  1231.         }
  1233.         $columnList = [];
  1234.         $this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r'); // r for root
  1236.         // Add regular columns to select list
  1237.         foreach ($this->class->fieldNames as $field) {
  1238.             $columnList[] = $this->getSelectColumnSQL($field, $this->class);
  1239.         }
  1241.         $this->currentPersisterContext->selectJoinSql = '';
  1242.         $eagerAliasCounter                            = 0;
  1244.         foreach ($this->class->associationMappings as $assocField => $assoc) {
  1245.             $assocColumnSQL = $this->getSelectColumnAssociationSQL($assocField, $assoc, $this->class);
  1247.             if ($assocColumnSQL) {
  1248.                 $columnList[] = $assocColumnSQL;
  1249.             }
  1251.             $isAssocToOneInverseSide = $assoc->isToOne() && ! $assoc->isOwningSide();
  1252.             $isAssocFromOneEager     = $assoc->isToOne() && $assoc->fetch === ClassMetadata::FETCH_EAGER;
  1254.             if (! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
  1255.                 continue;
  1256.             }
  1258.             if ($assoc->isToMany() && $this->currentPersisterContext->handlesLimits) {
  1259.                 continue;
  1260.             }
  1262.             $eagerEntity = $this->em->getClassMetadata($assoc->targetEntity);
  1264.             if ($eagerEntity->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  1265.                 continue; // now this is why you shouldn't use inheritance
  1266.             }
  1268.             $assocAlias = 'e' . ($eagerAliasCounter++);
  1269.             $this->currentPersisterContext->rsm->addJoinedEntityResult($assoc->targetEntity, $assocAlias, 'r', $assocField);
  1271.             foreach ($eagerEntity->fieldNames as $field) {
  1272.                 $columnList[] = $this->getSelectColumnSQL($field, $eagerEntity, $assocAlias);
  1273.             }
  1275.             foreach ($eagerEntity->associationMappings as $eagerAssocField => $eagerAssoc) {
  1276.                 $eagerAssocColumnSQL = $this->getSelectColumnAssociationSQL(
  1277.                     $eagerAssocField,
  1278.                     $eagerAssoc,
  1279.                     $eagerEntity,
  1280.                     $assocAlias,
  1281.                 );
  1283.                 if ($eagerAssocColumnSQL) {
  1284.                     $columnList[] = $eagerAssocColumnSQL;
  1285.                 }
  1286.             }
  1288.             $association   = $assoc;
  1289.             $joinCondition = [];
  1291.             if ($assoc->isIndexed()) {
  1292.                 assert($assoc->isToMany());
  1293.                 $this->currentPersisterContext->rsm->addIndexBy($assocAlias, $assoc->indexBy());
  1294.             }
  1296.             if (! $assoc->isOwningSide()) {
  1297.                 $eagerEntity = $this->em->getClassMetadata($assoc->targetEntity);
  1298.                 $association = $eagerEntity->getAssociationMapping($assoc->mappedBy);
  1299.             }
  1301.             assert($association->isToOneOwningSide());
  1303.             $joinTableAlias = $this->getSQLTableAlias($eagerEntity->name, $assocAlias);
  1304.             $joinTableName  = $this->quoteStrategy->getTableName($eagerEntity, $this->platform);
  1306.             if ($assoc->isOwningSide()) {
  1307.                 $tableAlias                                    = $this->getSQLTableAlias($association->targetEntity, $assocAlias);
  1308.                 $this->currentPersisterContext->selectJoinSql .= ' ' . $this->getJoinSQLForJoinColumns($association->joinColumns);
  1310.                 foreach ($association->joinColumns as $joinColumn) {
  1311.                     $sourceCol       = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1312.                     $targetCol       = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1313.                     $joinCondition[] = $this->getSQLTableAlias($association->sourceEntity)
  1314.                                         . '.' . $sourceCol . ' = ' . $tableAlias . '.' . $targetCol;
  1315.                 }
  1317.                 // Add filter SQL
  1318.                 $filterSql = $this->generateFilterConditionSQL($eagerEntity, $tableAlias);
  1319.                 if ($filterSql) {
  1320.                     $joinCondition[] = $filterSql;
  1321.                 }
  1322.             } else {
  1323.                 $this->currentPersisterContext->selectJoinSql .= ' LEFT JOIN';
  1325.                 foreach ($association->joinColumns as $joinColumn) {
  1326.                     $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1327.                     $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1329.                     $joinCondition[] = $this->getSQLTableAlias($association->sourceEntity, $assocAlias) . '.' . $sourceCol . ' = '
  1330.                         . $this->getSQLTableAlias($association->targetEntity) . '.' . $targetCol;
  1331.                 }
  1332.             }
  1334.             $this->currentPersisterContext->selectJoinSql .= ' ' . $joinTableName . ' ' . $joinTableAlias . ' ON ';
  1335.             $this->currentPersisterContext->selectJoinSql .= implode(' AND ', $joinCondition);
  1336.         }
  1338.         $this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
  1340.         return $this->currentPersisterContext->selectColumnListSql;
  1341.     }
  1343.     /** Gets the SQL join fragment used when selecting entities from an association. */
  1344.     protected function getSelectColumnAssociationSQL(
  1345.         string $field,
  1346.         AssociationMapping $assoc,
  1347.         ClassMetadata $class,
  1348.         string $alias = 'r',
  1349.     ): string {
  1350.         if (! $assoc->isToOneOwningSide()) {
  1351.             return '';
  1352.         }
  1354.         $columnList    = [];
  1355.         $targetClass   = $this->em->getClassMetadata($assoc->targetEntity);
  1356.         $isIdentifier  = isset($assoc->id) && $assoc->id === true;
  1357.         $sqlTableAlias = $this->getSQLTableAlias($class->name, ($alias === 'r' ? '' : $alias));
  1359.         foreach ($assoc->joinColumns as $joinColumn) {
  1360.             $quotedColumn     = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1361.             $resultColumnName = $this->getSQLColumnAlias($joinColumn->name);
  1362.             $type             = PersisterHelper::getTypeOfColumn($joinColumn->referencedColumnName, $targetClass, $this->em);
  1364.             $this->currentPersisterContext->rsm->addMetaResult($alias, $resultColumnName, $joinColumn->name, $isIdentifier, $type);
  1366.             $columnList[] = sprintf('%s.%s AS %s', $sqlTableAlias, $quotedColumn, $resultColumnName);
  1367.         }
  1369.         return implode(', ', $columnList);
  1370.     }
  1372.     /**
  1373.      * Gets the SQL join fragment used when selecting entities from a
  1374.      * many-to-many association.
  1375.      */
  1376.     protected function getSelectManyToManyJoinSQL(AssociationMapping&ManyToManyAssociationMapping $manyToMany): string
  1377.     {
  1378.         $conditions       = [];
  1379.         $association      = $manyToMany;
  1380.         $sourceTableAlias = $this->getSQLTableAlias($this->class->name);
  1382.         $association   = $this->em->getMetadataFactory()->getOwningSide($manyToMany);
  1383.         $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  1384.         $joinColumns   = $manyToMany->isOwningSide()
  1385.             ? $association->joinTable->inverseJoinColumns
  1386.             : $association->joinTable->joinColumns;
  1388.         foreach ($joinColumns as $joinColumn) {
  1389.             $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1390.             $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1391.             $conditions[]       = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableName . '.' . $quotedSourceColumn;
  1392.         }
  1394.         return ' INNER JOIN ' . $joinTableName . ' ON ' . implode(' AND ', $conditions);
  1395.     }
  1397.     public function getInsertSQL(): string
  1398.     {
  1399.         if ($this->insertSql !== null) {
  1400.             return $this->insertSql;
  1401.         }
  1403.         $columns   = $this->getInsertColumnList();
  1404.         $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1406.         if (empty($columns)) {
  1407.             $identityColumn  = $this->quoteStrategy->getColumnName($this->class->identifier[0], $this->class, $this->platform);
  1408.             $this->insertSql = $this->platform->getEmptyIdentityInsertSQL($tableName, $identityColumn);
  1410.             return $this->insertSql;
  1411.         }
  1413.         $values  = [];
  1414.         $columns = array_unique($columns);
  1416.         foreach ($columns as $column) {
  1417.             $placeholder = '?';
  1419.             if (
  1420.                 isset($this->class->fieldNames[$column])
  1421.                 && isset($this->columnTypes[$this->class->fieldNames[$column]])
  1422.                 && isset($this->class->fieldMappings[$this->class->fieldNames[$column]])
  1423.             ) {
  1424.                 $type        = Type::getType($this->columnTypes[$this->class->fieldNames[$column]]);
  1425.                 $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  1426.             }
  1428.             $values[] = $placeholder;
  1429.         }
  1431.         $columns = implode(', ', $columns);
  1432.         $values  = implode(', ', $values);
  1434.         $this->insertSql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $tableName, $columns, $values);
  1436.         return $this->insertSql;
  1437.     }
  1439.     /**
  1440.      * Gets the list of columns to put in the INSERT SQL statement.
  1441.      *
  1442.      * Subclasses should override this method to alter or change the list of
  1443.      * columns placed in the INSERT statements used by the persister.
  1444.      *
  1445.      * @psalm-return list<string>
  1446.      */
  1447.     protected function getInsertColumnList(): array
  1448.     {
  1449.         $columns = [];
  1451.         foreach ($this->class->reflFields as $name => $field) {
  1452.             if ($this->class->isVersioned && $this->class->versionField === $name) {
  1453.                 continue;
  1454.             }
  1456.             if (isset($this->class->embeddedClasses[$name])) {
  1457.                 continue;
  1458.             }
  1460.             if (isset($this->class->associationMappings[$name])) {
  1461.                 $assoc = $this->class->associationMappings[$name];
  1463.                 if ($assoc->isToOneOwningSide()) {
  1464.                     foreach ($assoc->joinColumns as $joinColumn) {
  1465.                         $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1466.                     }
  1467.                 }
  1469.                 continue;
  1470.             }
  1472.             if (! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] !== $name) {
  1473.                 if (isset($this->class->fieldMappings[$name]->notInsertable)) {
  1474.                     continue;
  1475.                 }
  1477.                 $columns[]                = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
  1478.                 $this->columnTypes[$name] = $this->class->fieldMappings[$name]->type;
  1479.             }
  1480.         }
  1482.         return $columns;
  1483.     }
  1485.     /**
  1486.      * Gets the SQL snippet of a qualified column name for the given field name.
  1487.      *
  1488.      * @param ClassMetadata $class The class that declares this field. The table this class is
  1489.      *                             mapped to must own the column for the given field.
  1490.      */
  1491.     protected function getSelectColumnSQL(string $field, ClassMetadata $class, string $alias = 'r'): string
  1492.     {
  1493.         $root         = $alias === 'r' ? '' : $alias;
  1494.         $tableAlias   = $this->getSQLTableAlias($class->name, $root);
  1495.         $fieldMapping = $class->fieldMappings[$field];
  1496.         $sql          = sprintf('%s.%s', $tableAlias, $this->quoteStrategy->getColumnName($field, $class, $this->platform));
  1497.         $columnAlias  = $this->getSQLColumnAlias($fieldMapping->columnName);
  1499.         $this->currentPersisterContext->rsm->addFieldResult($alias, $columnAlias, $field);
  1500.         if (! empty($fieldMapping->enumType)) {
  1501.             $this->currentPersisterContext->rsm->addEnumResult($columnAlias, $fieldMapping->enumType);
  1502.         }
  1504.         $type = Type::getType($fieldMapping->type);
  1505.         $sql  = $type->convertToPHPValueSQL($sql, $this->platform);
  1507.         return $sql . ' AS ' . $columnAlias;
  1508.     }
  1510.     /**
  1511.      * Gets the SQL table alias for the given class name.
  1512.      *
  1513.      * @todo Reconsider. Binding table aliases to class names is not such a good idea.
  1514.      */
  1515.     protected function getSQLTableAlias(string $className, string $assocName = ''): string
  1516.     {
  1517.         if ($assocName) {
  1518.             $className .= '#' . $assocName;
  1519.         }
  1521.         if (isset($this->currentPersisterContext->sqlTableAliases[$className])) {
  1522.             return $this->currentPersisterContext->sqlTableAliases[$className];
  1523.         }
  1525.         $tableAlias = 't' . $this->currentPersisterContext->sqlAliasCounter++;
  1527.         $this->currentPersisterContext->sqlTableAliases[$className] = $tableAlias;
  1529.         return $tableAlias;
  1530.     }
  1532.     /**
  1533.      * {@inheritDoc}
  1534.      */
  1535.     public function lock(array $criteria, LockMode|int $lockMode): void
  1536.     {
  1537.         $conditionSql = $this->getSelectConditionSQL($criteria);
  1539.         $lockSql = match ($lockMode) {
  1540.             LockMode::PESSIMISTIC_READ => $this->getReadLockSQL($this->platform),
  1541.             LockMode::PESSIMISTIC_WRITE => $this->getWriteLockSQL($this->platform),
  1542.             default => '',
  1543.         };
  1545.         $lock  = $this->getLockTablesSql($lockMode);
  1546.         $where = ($conditionSql ? ' WHERE ' . $conditionSql : '') . ' ';
  1547.         $sql   = 'SELECT 1 '
  1548.              . $lock
  1549.              . $where
  1550.              . $lockSql;
  1552.         [$params, $types] = $this->expandParameters($criteria);
  1554.         $this->conn->executeQuery($sql, $params, $types);
  1555.     }
  1557.     /**
  1558.      * Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.
  1559.      *
  1560.      * @psalm-param LockMode::* $lockMode
  1561.      */
  1562.     protected function getLockTablesSql(LockMode|int $lockMode): string
  1563.     {
  1564.         return $this->platform->appendLockHint(
  1565.             'FROM '
  1566.             . $this->quoteStrategy->getTableName($this->class, $this->platform) . ' '
  1567.             . $this->getSQLTableAlias($this->class->name),
  1568.             $lockMode,
  1569.         );
  1570.     }
  1572.     /**
  1573.      * Gets the Select Where Condition from a Criteria object.
  1574.      */
  1575.     protected function getSelectConditionCriteriaSQL(Criteria $criteria): string
  1576.     {
  1577.         $expression = $criteria->getWhereExpression();
  1579.         if ($expression === null) {
  1580.             return '';
  1581.         }
  1583.         $visitor = new SqlExpressionVisitor($this, $this->class);
  1585.         return $visitor->dispatch($expression);
  1586.     }
  1588.     public function getSelectConditionStatementSQL(
  1589.         string $field,
  1590.         mixed $value,
  1591.         AssociationMapping|null $assoc = null,
  1592.         string|null $comparison = null,
  1593.     ): string {
  1594.         $selectedColumns = [];
  1595.         $columns         = $this->getSelectConditionStatementColumnSQL($field, $assoc);
  1597.         if (count($columns) > 1 && $comparison === Comparison::IN) {
  1598.             /*
  1599.              *  @todo try to support multi-column IN expressions.
  1600.              *  Example: (col1, col2) IN (('val1A', 'val2A'), ('val1B', 'val2B'))
  1601.              */
  1602.             throw CantUseInOperatorOnCompositeKeys::create();
  1603.         }
  1605.         foreach ($columns as $column) {
  1606.             $placeholder = '?';
  1608.             if (isset($this->class->fieldMappings[$field])) {
  1609.                 $type        = Type::getType($this->class->fieldMappings[$field]->type);
  1610.                 $placeholder = $type->convertToDatabaseValueSQL($placeholder, $this->platform);
  1611.             }
  1613.             if ($comparison !== null) {
  1614.                 // special case null value handling
  1615.                 if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && $value === null) {
  1616.                     $selectedColumns[] = $column . ' IS NULL';
  1618.                     continue;
  1619.                 }
  1621.                 if ($comparison === Comparison::NEQ && $value === null) {
  1622.                     $selectedColumns[] = $column . ' IS NOT NULL';
  1624.                     continue;
  1625.                 }
  1627.                 $selectedColumns[] = $column . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);
  1629.                 continue;
  1630.             }
  1632.             if (is_array($value)) {
  1633.                 $in = sprintf('%s IN (%s)', $column, $placeholder);
  1635.                 if (array_search(null, $value, true) !== false) {
  1636.                     $selectedColumns[] = sprintf('(%s OR %s IS NULL)', $in, $column);
  1638.                     continue;
  1639.                 }
  1641.                 $selectedColumns[] = $in;
  1643.                 continue;
  1644.             }
  1646.             if ($value === null) {
  1647.                 $selectedColumns[] = sprintf('%s IS NULL', $column);
  1649.                 continue;
  1650.             }
  1652.             $selectedColumns[] = sprintf('%s = %s', $column, $placeholder);
  1653.         }
  1655.         return implode(' AND ', $selectedColumns);
  1656.     }
  1658.     /**
  1659.      * Builds the left-hand-side of a where condition statement.
  1660.      *
  1661.      * @return string[]
  1662.      * @psalm-return list<string>
  1663.      *
  1664.      * @throws InvalidFindByCall
  1665.      * @throws UnrecognizedField
  1666.      */
  1667.     private function getSelectConditionStatementColumnSQL(
  1668.         string $field,
  1669.         AssociationMapping|null $assoc = null,
  1670.     ): array {
  1671.         if (isset($this->class->fieldMappings[$field])) {
  1672.             $className = $this->class->fieldMappings[$field]->inherited ?? $this->class->name;
  1674.             return [$this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getColumnName($field, $this->class, $this->platform)];
  1675.         }
  1677.         if (isset($this->class->associationMappings[$field])) {
  1678.             $association = $this->class->associationMappings[$field];
  1679.             // Many-To-Many requires join table check for joinColumn
  1680.             $columns = [];
  1681.             $class   = $this->class;
  1683.             if ($association->isManyToMany()) {
  1684.                 assert($assoc !== null);
  1685.                 if (! $association->isOwningSide()) {
  1686.                     $association = $assoc;
  1687.                 }
  1689.                 assert($association->isManyToManyOwningSide());
  1691.                 $joinTableName = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1692.                 $joinColumns   = $assoc->isOwningSide()
  1693.                     ? $association->joinTable->joinColumns
  1694.                     : $association->joinTable->inverseJoinColumns;
  1696.                 foreach ($joinColumns as $joinColumn) {
  1697.                     $columns[] = $joinTableName . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1698.                 }
  1699.             } else {
  1700.                 if (! $association->isOwningSide()) {
  1701.                     throw InvalidFindByCall::fromInverseSideUsage(
  1702.                         $this->class->name,
  1703.                         $field,
  1704.                     );
  1705.                 }
  1707.                 assert($association->isToOneOwningSide());
  1709.                 $className = $association->inherited ?? $this->class->name;
  1711.                 foreach ($association->joinColumns as $joinColumn) {
  1712.                     $columns[] = $this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1713.                 }
  1714.             }
  1716.             return $columns;
  1717.         }
  1719.         if ($assoc !== null && ! str_contains($field, ' ') && ! str_contains($field, '(')) {
  1720.             // very careless developers could potentially open up this normally hidden api for userland attacks,
  1721.             // therefore checking for spaces and function calls which are not allowed.
  1723.             // found a join column condition, not really a "field"
  1724.             return [$field];
  1725.         }
  1727.         throw UnrecognizedField::byFullyQualifiedName($this->class->name, $field);
  1728.     }
  1730.     /**
  1731.      * Gets the conditional SQL fragment used in the WHERE clause when selecting
  1732.      * entities in this persister.
  1733.      *
  1734.      * Subclasses are supposed to override this method if they intend to change
  1735.      * or alter the criteria by which entities are selected.
  1736.      *
  1737.      * @psalm-param array<string, mixed> $criteria
  1738.      */
  1739.     protected function getSelectConditionSQL(array $criteria, AssociationMapping|null $assoc = null): string
  1740.     {
  1741.         $conditions = [];
  1743.         foreach ($criteria as $field => $value) {
  1744.             $conditions[] = $this->getSelectConditionStatementSQL($field, $value, $assoc);
  1745.         }
  1747.         return implode(' AND ', $conditions);
  1748.     }
  1750.     /**
  1751.      * {@inheritDoc}
  1752.      */
  1753.     public function getOneToManyCollection(
  1754.         AssociationMapping $assoc,
  1755.         object $sourceEntity,
  1756.         int|null $offset = null,
  1757.         int|null $limit = null,
  1758.     ): array {
  1759.         assert($assoc instanceof OneToManyAssociationMapping);
  1760.         $this->switchPersisterContext($offset, $limit);
  1762.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity, $offset, $limit);
  1764.         return $this->loadArrayFromResult($assoc, $stmt);
  1765.     }
  1767.     public function loadOneToManyCollection(
  1768.         AssociationMapping $assoc,
  1769.         object $sourceEntity,
  1770.         PersistentCollection $collection,
  1771.     ): mixed {
  1772.         assert($assoc instanceof OneToManyAssociationMapping);
  1773.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity);
  1775.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1776.     }
  1778.     /** Builds criteria and execute SQL statement to fetch the one to many entities from. */
  1779.     private function getOneToManyStatement(
  1780.         OneToManyAssociationMapping $assoc,
  1781.         object $sourceEntity,
  1782.         int|null $offset = null,
  1783.         int|null $limit = null,
  1784.     ): Result {
  1785.         $this->switchPersisterContext($offset, $limit);
  1787.         $criteria    = [];
  1788.         $parameters  = [];
  1789.         $owningAssoc = $this->class->associationMappings[$assoc->mappedBy];
  1790.         $sourceClass = $this->em->getClassMetadata($assoc->sourceEntity);
  1791.         $tableAlias  = $this->getSQLTableAlias($owningAssoc->inherited ?? $this->class->name);
  1792.         assert($owningAssoc->isManyToOne());
  1794.         foreach ($owningAssoc->targetToSourceKeyColumns as $sourceKeyColumn => $targetKeyColumn) {
  1795.             if ($sourceClass->containsForeignIdentifier) {
  1796.                 $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1797.                 $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1799.                 if (isset($sourceClass->associationMappings[$field])) {
  1800.                     $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1801.                     $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]->targetEntity)->identifier[0]];
  1802.                 }
  1804.                 $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1805.                 $parameters[]                                   = [
  1806.                     'value' => $value,
  1807.                     'field' => $field,
  1808.                     'class' => $sourceClass,
  1809.                 ];
  1811.                 continue;
  1812.             }
  1814.             $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1815.             $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1817.             $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1818.             $parameters[]                                   = [
  1819.                 'value' => $value,
  1820.                 'field' => $field,
  1821.                 'class' => $sourceClass,
  1822.             ];
  1823.         }
  1825.         $sql              = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1826.         [$params, $types] = $this->expandToManyParameters($parameters);
  1828.         return $this->conn->executeQuery($sql, $params, $types);
  1829.     }
  1831.     /**
  1832.      * {@inheritDoc}
  1833.      */
  1834.     public function expandParameters(array $criteria): array
  1835.     {
  1836.         $params = [];
  1837.         $types  = [];
  1839.         foreach ($criteria as $field => $value) {
  1840.             if ($value === null) {
  1841.                 continue; // skip null values.
  1842.             }
  1844.             $types  = [...$types, ...$this->getTypes($field, $value, $this->class)];
  1845.             $params = array_merge($params, $this->getValues($value));
  1846.         }
  1848.         return [$params, $types];
  1849.     }
  1851.     /**
  1852.      * Expands the parameters from the given criteria and use the correct binding types if found,
  1853.      * specialized for OneToMany or ManyToMany associations.
  1854.      *
  1855.      * @param mixed[][] $criteria an array of arrays containing following:
  1856.      *                             - field to which each criterion will be bound
  1857.      *                             - value to be bound
  1858.      *                             - class to which the field belongs to
  1859.      *
  1860.      * @return mixed[][]
  1861.      * @psalm-return array{0: array, 1: list<ParameterType::*|ArrayParameterType::*|string>}
  1862.      */
  1863.     private function expandToManyParameters(array $criteria): array
  1864.     {
  1865.         $params = [];
  1866.         $types  = [];
  1868.         foreach ($criteria as $criterion) {
  1869.             if ($criterion['value'] === null) {
  1870.                 continue; // skip null values.
  1871.             }
  1873.             $types  = [...$types, ...$this->getTypes($criterion['field'], $criterion['value'], $criterion['class'])];
  1874.             $params = array_merge($params, $this->getValues($criterion['value']));
  1875.         }
  1877.         return [$params, $types];
  1878.     }
  1880.     /**
  1881.      * Infers field types to be used by parameter type casting.
  1882.      *
  1883.      * @return list<ParameterType|ArrayParameterType|int|string>
  1884.      * @psalm-return list<ParameterType::*|ArrayParameterType::*|string>
  1885.      *
  1886.      * @throws QueryException
  1887.      */
  1888.     private function getTypes(string $field, mixed $value, ClassMetadata $class): array
  1889.     {
  1890.         $types = [];
  1892.         switch (true) {
  1893.             case isset($class->fieldMappings[$field]):
  1894.                 $types = array_merge($types, [$class->fieldMappings[$field]->type]);
  1895.                 break;
  1897.             case isset($class->associationMappings[$field]):
  1898.                 $assoc = $this->em->getMetadataFactory()->getOwningSide($class->associationMappings[$field]);
  1899.                 $class = $this->em->getClassMetadata($assoc->targetEntity);
  1901.                 if ($assoc->isManyToManyOwningSide()) {
  1902.                     $columns = $assoc->relationToTargetKeyColumns;
  1903.                 } else {
  1904.                     assert($assoc->isToOneOwningSide());
  1905.                     $columns = $assoc->sourceToTargetKeyColumns;
  1906.                 }
  1908.                 foreach ($columns as $column) {
  1909.                     $types[] = PersisterHelper::getTypeOfColumn($column, $class, $this->em);
  1910.                 }
  1912.                 break;
  1914.             default:
  1915.                 $types[] = ParameterType::STRING;
  1916.                 break;
  1917.         }
  1919.         if (is_array($value)) {
  1920.             return array_map($this->getArrayBindingType(...), $types);
  1921.         }
  1923.         return $types;
  1924.     }
  1926.     /** @psalm-return ArrayParameterType::* */
  1927.     private function getArrayBindingType(ParameterType|int|string $type): ArrayParameterType|int
  1928.     {
  1929.         if (! $type instanceof ParameterType) {
  1930.             $type = Type::getType((string) $type)->getBindingType();
  1931.         }
  1933.         return match ($type) {
  1934.             ParameterType::STRING => ArrayParameterType::STRING,
  1935.             ParameterType::INTEGER => ArrayParameterType::INTEGER,
  1936.             ParameterType::ASCII => ArrayParameterType::ASCII,
  1937.         };
  1938.     }
  1940.     /**
  1941.      * Retrieves the parameters that identifies a value.
  1942.      *
  1943.      * @return mixed[]
  1944.      */
  1945.     private function getValues(mixed $value): array
  1946.     {
  1947.         if (is_array($value)) {
  1948.             $newValue = [];
  1950.             foreach ($value as $itemValue) {
  1951.                 $newValue = array_merge($newValue, $this->getValues($itemValue));
  1952.             }
  1954.             return [$newValue];
  1955.         }
  1957.         return $this->getIndividualValue($value);
  1958.     }
  1960.     /**
  1961.      * Retrieves an individual parameter value.
  1962.      *
  1963.      * @psalm-return list<mixed>
  1964.      */
  1965.     private function getIndividualValue(mixed $value): array
  1966.     {
  1967.         if (! is_object($value)) {
  1968.             return [$value];
  1969.         }
  1971.         if ($value instanceof BackedEnum) {
  1972.             return [$value->value];
  1973.         }
  1975.         $valueClass = DefaultProxyClassNameResolver::getClass($value);
  1977.         if ($this->em->getMetadataFactory()->isTransient($valueClass)) {
  1978.             return [$value];
  1979.         }
  1981.         $class = $this->em->getClassMetadata($valueClass);
  1983.         if ($class->isIdentifierComposite) {
  1984.             $newValue = [];
  1986.             foreach ($class->getIdentifierValues($value) as $innerValue) {
  1987.                 $newValue = array_merge($newValue, $this->getValues($innerValue));
  1988.             }
  1990.             return $newValue;
  1991.         }
  1993.         return [$this->em->getUnitOfWork()->getSingleIdentifierValue($value)];
  1994.     }
  1996.     public function exists(object $entity, Criteria|null $extraConditions = null): bool
  1997.     {
  1998.         $criteria = $this->class->getIdentifierValues($entity);
  2000.         if (! $criteria) {
  2001.             return false;
  2002.         }
  2004.         $alias = $this->getSQLTableAlias($this->class->name);
  2006.         $sql = 'SELECT 1 '
  2007.              . $this->getLockTablesSql(LockMode::NONE)
  2008.              . ' WHERE ' . $this->getSelectConditionSQL($criteria);
  2010.         [$params, $types] = $this->expandParameters($criteria);
  2012.         if ($extraConditions !== null) {
  2013.             $sql                             .= ' AND ' . $this->getSelectConditionCriteriaSQL($extraConditions);
  2014.             [$criteriaParams, $criteriaTypes] = $this->expandCriteriaParameters($extraConditions);
  2016.             $params = [...$params, ...$criteriaParams];
  2017.             $types  = [...$types, ...$criteriaTypes];
  2018.         }
  2020.         $filterSql = $this->generateFilterConditionSQL($this->class, $alias);
  2021.         if ($filterSql) {
  2022.             $sql .= ' AND ' . $filterSql;
  2023.         }
  2025.         return (bool) $this->conn->fetchOne($sql, $params, $types);
  2026.     }
  2028.     /**
  2029.      * Generates the appropriate join SQL for the given join column.
  2030.      *
  2031.      * @param list<JoinColumnMapping> $joinColumns The join columns definition of an association.
  2032.      *
  2033.      * @return string LEFT JOIN if one of the columns is nullable, INNER JOIN otherwise.
  2034.      */
  2035.     protected function getJoinSQLForJoinColumns(array $joinColumns): string
  2036.     {
  2037.         // if one of the join columns is nullable, return left join
  2038.         foreach ($joinColumns as $joinColumn) {
  2039.             if (! isset($joinColumn->nullable) || $joinColumn->nullable) {
  2040.                 return 'LEFT JOIN';
  2041.             }
  2042.         }
  2044.         return 'INNER JOIN';
  2045.     }
  2047.     public function getSQLColumnAlias(string $columnName): string
  2048.     {
  2049.         return $this->quoteStrategy->getColumnAlias($columnName, $this->currentPersisterContext->sqlAliasCounter++, $this->platform);
  2050.     }
  2052.     /**
  2053.      * Generates the filter SQL for a given entity and table alias.
  2054.      *
  2055.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  2056.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  2057.      *
  2058.      * @return string The SQL query part to add to a query.
  2059.      */
  2060.     protected function generateFilterConditionSQL(ClassMetadata $targetEntity, string $targetTableAlias): string
  2061.     {
  2062.         $filterClauses = [];
  2064.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  2065.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  2066.             if ($filterExpr !== '') {
  2067.                 $filterClauses[] = '(' . $filterExpr . ')';
  2068.             }
  2069.         }
  2071.         $sql = implode(' AND ', $filterClauses);
  2073.         return $sql ? '(' . $sql . ')' : ''; // Wrap again to avoid "X or Y and FilterConditionSQL"
  2074.     }
  2076.     /**
  2077.      * Switches persister context according to current query offset/limits
  2078.      *
  2079.      * This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved
  2080.      */
  2081.     protected function switchPersisterContext(int|null $offset, int|null $limit): void
  2082.     {
  2083.         if ($offset === null && $limit === null) {
  2084.             $this->currentPersisterContext = $this->noLimitsContext;
  2086.             return;
  2087.         }
  2089.         $this->currentPersisterContext = $this->limitsHandlingContext;
  2090.     }
  2092.     /**
  2093.      * @return string[]
  2094.      * @psalm-return list<string>
  2095.      */
  2096.     protected function getClassIdentifiersTypes(ClassMetadata $class): array
  2097.     {
  2098.         $entityManager = $this->em;
  2100.         return array_map(
  2101.             static function ($fieldName) use ($class, $entityManager): string {
  2102.                 $types = PersisterHelper::getTypeOfField($fieldName, $class, $entityManager);
  2103.                 assert(isset($types[0]));
  2105.                 return $types[0];
  2106.             },
  2107.             $class->identifier,
  2108.         );
  2109.     }
  2110. }